Fixed audio visual activation introduced by [eff24974c62da8740d381ae45694474ac1ee2c05]
[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-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
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33
34 #include <stdio.h>
35 #include <string.h>
36 #include <math.h>
37 #include <assert.h>
38
39 #include <vlc_input.h>                 /* for input_thread_t and i_pts_delay */
40
41 #ifdef HAVE_ALLOCA_H
42 #   include <alloca.h>
43 #endif
44 #include <vlc_aout.h>
45
46 #include "aout_internal.h"
47
48 /** FIXME: Ugly but needed to access the counters */
49 #include "input/input_internal.h"
50
51 #define AOUT_ASSERT_MIXER_LOCKED vlc_assert_locked( &p_aout->mixer_lock )
52 #define AOUT_ASSERT_INPUT_LOCKED vlc_assert_locked( &p_input->lock )
53
54 static void inputFailure( aout_instance_t *, aout_input_t *, const char * );
55 static void inputDrop( aout_instance_t *, aout_input_t *, aout_buffer_t * );
56 static void inputResamplingStop( aout_input_t *p_input );
57
58 static int VisualizationCallback( vlc_object_t *, char const *,
59                                   vlc_value_t, vlc_value_t, void * );
60 static int EqualizerCallback( vlc_object_t *, char const *,
61                               vlc_value_t, vlc_value_t, void * );
62 static int ReplayGainCallback( vlc_object_t *, char const *,
63                                vlc_value_t, vlc_value_t, void * );
64 static void ReplayGainSelect( aout_instance_t *, aout_input_t * );
65 /*****************************************************************************
66  * aout_InputNew : allocate a new input and rework the filter pipeline
67  *****************************************************************************/
68 int aout_InputNew( aout_instance_t * p_aout, aout_input_t * p_input )
69 {
70     audio_sample_format_t chain_input_format;
71     audio_sample_format_t chain_output_format;
72     vlc_value_t val, text;
73     char *psz_filters, *psz_visual, *psz_scaletempo;
74     int i_visual;
75
76     aout_FormatPrint( p_aout, "input", &p_input->input );
77
78     p_input->i_nb_resamplers = p_input->i_nb_filters = 0;
79
80     /* Prepare FIFO. */
81     aout_FifoInit( p_aout, &p_input->fifo, p_aout->mixer.mixer.i_rate );
82     p_input->p_first_byte_to_mix = NULL;
83
84     /* Prepare format structure */
85     memcpy( &chain_input_format, &p_input->input,
86             sizeof(audio_sample_format_t) );
87     memcpy( &chain_output_format, &p_aout->mixer.mixer,
88             sizeof(audio_sample_format_t) );
89     chain_output_format.i_rate = p_input->input.i_rate;
90     aout_FormatPrepare( &chain_output_format );
91
92     /* Now add user filters */
93     if( var_Type( p_aout, "visual" ) == 0 )
94     {
95         var_Create( p_aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE );
96         text.psz_string = _("Visualizations");
97         var_Change( p_aout, "visual", VLC_VAR_SETTEXT, &text, NULL );
98         val.psz_string = (char*)""; text.psz_string = _("Disable");
99         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
100         val.psz_string = (char*)"spectrometer"; text.psz_string = _("Spectrometer");
101         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
102         val.psz_string = (char*)"scope"; text.psz_string = _("Scope");
103         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
104         val.psz_string = (char*)"spectrum"; text.psz_string = _("Spectrum");
105         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
106         val.psz_string = (char*)"vuMeter"; text.psz_string = _("Vu meter");
107         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
108
109         /* Look for goom plugin */
110         if( module_Exists( VLC_OBJECT(p_aout), "goom" ) )
111         {
112             val.psz_string = (char*)"goom"; text.psz_string = (char*)"Goom";
113             var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
114         }
115
116         /* Look for galaktos plugin */
117         if( module_Exists( VLC_OBJECT(p_aout), "galaktos" ) )
118         {
119             val.psz_string = (char*)"galaktos"; text.psz_string = (char*)"GaLaktos";
120             var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
121         }
122
123         if( var_Get( p_aout, "effect-list", &val ) == VLC_SUCCESS )
124         {
125             var_Set( p_aout, "visual", val );
126             free( val.psz_string );
127         }
128         var_AddCallback( p_aout, "visual", VisualizationCallback, NULL );
129     }
130
131     if( var_Type( p_aout, "equalizer" ) == 0 )
132     {
133         module_config_t *p_config;
134         int i;
135
136         p_config = config_FindConfig( VLC_OBJECT(p_aout), "equalizer-preset" );
137         if( p_config && p_config->i_list )
138         {
139                var_Create( p_aout, "equalizer",
140                            VLC_VAR_STRING | VLC_VAR_HASCHOICE );
141             text.psz_string = _("Equalizer");
142             var_Change( p_aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL );
143
144             val.psz_string = (char*)""; text.psz_string = _("Disable");
145             var_Change( p_aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text );
146
147             for( i = 0; i < p_config->i_list; i++ )
148             {
149                 val.psz_string = (char *)p_config->ppsz_list[i];
150                 text.psz_string = (char *)p_config->ppsz_list_text[i];
151                 var_Change( p_aout, "equalizer", VLC_VAR_ADDCHOICE,
152                             &val, &text );
153             }
154
155             var_AddCallback( p_aout, "equalizer", EqualizerCallback, NULL );
156         }
157     }
158
159     if( var_Type( p_aout, "audio-filter" ) == 0 )
160     {
161         var_Create( p_aout, "audio-filter",
162                     VLC_VAR_STRING | VLC_VAR_DOINHERIT );
163         text.psz_string = _("Audio filters");
164         var_Change( p_aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL );
165     }
166     if( var_Type( p_aout, "audio-visual" ) == 0 )
167     {
168         var_Create( p_aout, "audio-visual",
169                     VLC_VAR_STRING | VLC_VAR_DOINHERIT );
170         text.psz_string = _("Audio visualizations");
171         var_Change( p_aout, "audio-visual", VLC_VAR_SETTEXT, &text, NULL );
172     }
173
174     if( var_Type( p_aout, "audio-replay-gain-mode" ) == 0 )
175     {
176         module_config_t *p_config;
177         int i;
178
179         p_config = config_FindConfig( VLC_OBJECT(p_aout), "audio-replay-gain-mode" );
180         if( p_config && p_config->i_list )
181         {
182             var_Create( p_aout, "audio-replay-gain-mode",
183                         VLC_VAR_STRING | VLC_VAR_DOINHERIT );
184
185             text.psz_string = _("Replay gain");
186             var_Change( p_aout, "audio-replay-gain-mode", VLC_VAR_SETTEXT, &text, NULL );
187
188             for( i = 0; i < p_config->i_list; i++ )
189             {
190                 val.psz_string = (char *)p_config->ppsz_list[i];
191                 text.psz_string = (char *)p_config->ppsz_list_text[i];
192                 var_Change( p_aout, "audio-replay-gain-mode", VLC_VAR_ADDCHOICE,
193                             &val, &text );
194             }
195
196             var_AddCallback( p_aout, "audio-replay-gain-mode", ReplayGainCallback, NULL );
197         }
198     }
199     if( var_Type( p_aout, "audio-replay-gain-preamp" ) == 0 )
200     {
201         var_Create( p_aout, "audio-replay-gain-preamp",
202                     VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
203     }
204     if( var_Type( p_aout, "audio-replay-gain-default" ) == 0 )
205     {
206         var_Create( p_aout, "audio-replay-gain-default",
207                     VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
208     }
209     if( var_Type( p_aout, "audio-replay-gain-peak-protection" ) == 0 )
210     {
211         var_Create( p_aout, "audio-replay-gain-peak-protection",
212                     VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
213     }
214     if( var_Type( p_aout, "audio-time-stretch" ) == 0 )
215     {
216         var_Create( p_aout, "audio-time-stretch",
217                     VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
218     }
219
220     var_Get( p_aout, "audio-filter", &val );
221     psz_filters = val.psz_string;
222     var_Get( p_aout, "audio-visual", &val );
223     psz_visual = val.psz_string;
224
225     psz_scaletempo = var_GetBool( p_aout, "audio-time-stretch" ) ? strdup( "scaletempo" ) : NULL;
226
227     /* parse user filter lists */
228     for( i_visual = 0; i_visual < 3; i_visual++ )
229     {
230         char *ppsz_array[] = { psz_scaletempo, psz_filters, psz_visual };
231         char *psz_next = NULL;
232         char *psz_parser = ppsz_array[i_visual];
233
234         if( psz_parser == NULL || !*psz_parser )
235             continue;
236
237         while( psz_parser && *psz_parser )
238         {
239             aout_filter_t * p_filter = NULL;
240
241             if( p_input->i_nb_filters >= AOUT_MAX_FILTERS )
242             {
243                 msg_Dbg( p_aout, "max filters reached (%d)", AOUT_MAX_FILTERS );
244                 break;
245             }
246
247             while( *psz_parser == ' ' && *psz_parser == ':' )
248             {
249                 psz_parser++;
250             }
251             if( ( psz_next = strchr( psz_parser , ':'  ) ) )
252             {
253                 *psz_next++ = '\0';
254             }
255             if( *psz_parser =='\0' )
256             {
257                 break;
258             }
259
260             /* Create a VLC object */
261             static const char typename[] = "audio filter";
262             p_filter = vlc_custom_create( p_aout, sizeof(*p_filter),
263                                           VLC_OBJECT_GENERIC, typename );
264             if( p_filter == NULL )
265             {
266                 msg_Err( p_aout, "cannot add user filter %s (skipped)",
267                          psz_parser );
268                 psz_parser = psz_next;
269                 continue;
270             }
271
272             vlc_object_attach( p_filter , p_aout );
273
274             /* try to find the requested filter */
275             if( i_visual == 2 ) /* this can only be a visualization module */
276             {
277                 /* request format */
278                 memcpy( &p_filter->input, &chain_output_format,
279                         sizeof(audio_sample_format_t) );
280                 memcpy( &p_filter->output, &chain_output_format,
281                         sizeof(audio_sample_format_t) );
282
283                 p_filter->p_module = module_Need( p_filter, "visualization",
284                                                   psz_parser, true );
285             }
286             else /* this can be a audio filter module as well as a visualization module */
287             {
288                 /* request format */
289                 memcpy( &p_filter->input, &chain_input_format,
290                         sizeof(audio_sample_format_t) );
291                 memcpy( &p_filter->output, &chain_output_format,
292                         sizeof(audio_sample_format_t) );
293
294                 p_filter->p_module = module_Need( p_filter, "audio filter",
295                                               psz_parser, true );
296
297                 if ( p_filter->p_module == NULL )
298                 {
299                     /* if the filter requested a special format, retry */
300                     if ( !( AOUT_FMTS_IDENTICAL( &p_filter->input,
301                                                  &chain_input_format )
302                             && AOUT_FMTS_IDENTICAL( &p_filter->output,
303                                                     &chain_output_format ) ) )
304                     {
305                         aout_FormatPrepare( &p_filter->input );
306                         aout_FormatPrepare( &p_filter->output );
307                         p_filter->p_module = module_Need( p_filter,
308                                                           "audio filter",
309                                                           psz_parser, true );
310                     }
311                     /* try visual filters */
312                     else
313                     {
314                         memcpy( &p_filter->input, &chain_output_format,
315                                 sizeof(audio_sample_format_t) );
316                         memcpy( &p_filter->output, &chain_output_format,
317                                 sizeof(audio_sample_format_t) );
318                         p_filter->p_module = module_Need( p_filter,
319                                                           "visualization",
320                                                           psz_parser, true );
321                     }
322                 }
323             }
324
325             /* failure */
326             if ( p_filter->p_module == NULL )
327             {
328                 msg_Err( p_aout, "cannot add user filter %s (skipped)",
329                          psz_parser );
330
331                 vlc_object_detach( p_filter );
332                 vlc_object_release( p_filter );
333
334                 psz_parser = psz_next;
335                 continue;
336             }
337
338             /* complete the filter chain if necessary */
339             if ( !AOUT_FMTS_IDENTICAL( &chain_input_format, &p_filter->input ) )
340             {
341                 if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters,
342                                                  &p_input->i_nb_filters,
343                                                  &chain_input_format,
344                                                  &p_filter->input ) < 0 )
345                 {
346                     msg_Err( p_aout, "cannot add user filter %s (skipped)",
347                              psz_parser );
348
349                     module_Unneed( p_filter, p_filter->p_module );
350                     vlc_object_detach( p_filter );
351                     vlc_object_release( p_filter );
352
353                     psz_parser = psz_next;
354                     continue;
355                 }
356             }
357
358             /* success */
359             p_filter->b_continuity = false;
360             p_input->pp_filters[p_input->i_nb_filters++] = p_filter;
361             memcpy( &chain_input_format, &p_filter->output,
362                     sizeof( audio_sample_format_t ) );
363
364             /* next filter if any */
365             psz_parser = psz_next;
366         }
367     }
368     free( psz_visual );
369     free( psz_filters );
370     free( psz_scaletempo );
371
372     /* complete the filter chain if necessary */
373     if ( !AOUT_FMTS_IDENTICAL( &chain_input_format, &chain_output_format ) )
374     {
375         if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters,
376                                          &p_input->i_nb_filters,
377                                          &chain_input_format,
378                                          &chain_output_format ) < 0 )
379         {
380             inputFailure( p_aout, p_input, "couldn't set an input pipeline" );
381             return -1;
382         }
383     }
384
385     /* Prepare hints for the buffer allocator. */
386     p_input->input_alloc.i_alloc_type = AOUT_ALLOC_HEAP;
387     p_input->input_alloc.i_bytes_per_sec = -1;
388
389     /* Create resamplers. */
390     if ( !AOUT_FMT_NON_LINEAR( &p_aout->mixer.mixer ) )
391     {
392         chain_output_format.i_rate = (__MAX(p_input->input.i_rate,
393                                             p_aout->mixer.mixer.i_rate)
394                                  * (100 + AOUT_MAX_RESAMPLING)) / 100;
395         if ( chain_output_format.i_rate == p_aout->mixer.mixer.i_rate )
396         {
397             /* Just in case... */
398             chain_output_format.i_rate++;
399         }
400         if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_resamplers,
401                                          &p_input->i_nb_resamplers,
402                                          &chain_output_format,
403                                          &p_aout->mixer.mixer ) < 0 )
404         {
405             inputFailure( p_aout, p_input, "couldn't set a resampler pipeline");
406             return -1;
407         }
408
409         aout_FiltersHintBuffers( p_aout, p_input->pp_resamplers,
410                                  p_input->i_nb_resamplers,
411                                  &p_input->input_alloc );
412         p_input->input_alloc.i_alloc_type = AOUT_ALLOC_HEAP;
413
414         /* Setup the initial rate of the resampler */
415         p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
416     }
417     p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
418
419     p_input->p_playback_rate_filter = NULL;
420     for( int i = 0; i < p_input->i_nb_filters; i++ )
421     {
422         aout_filter_t *p_filter = p_input->pp_filters[i];
423         if( strcmp( "scaletempo", p_filter->psz_object_name ) == 0 )
424         {
425           p_input->p_playback_rate_filter = p_filter;
426           break;
427         }
428     }
429     if( ! p_input->p_playback_rate_filter && p_input->i_nb_resamplers > 0 )
430     {
431         p_input->p_playback_rate_filter = p_input->pp_resamplers[0];
432     }
433
434     aout_FiltersHintBuffers( p_aout, p_input->pp_filters,
435                              p_input->i_nb_filters,
436                              &p_input->input_alloc );
437     p_input->input_alloc.i_alloc_type = AOUT_ALLOC_HEAP;
438
439     /* i_bytes_per_sec is still == -1 if no filters */
440     p_input->input_alloc.i_bytes_per_sec = __MAX(
441                                     p_input->input_alloc.i_bytes_per_sec,
442                                     (int)(p_input->input.i_bytes_per_frame
443                                      * p_input->input.i_rate
444                                      / p_input->input.i_frame_length) );
445
446     ReplayGainSelect( p_aout, p_input );
447
448     /* Success */
449     p_input->b_error = false;
450     p_input->b_restart = false;
451     p_input->i_last_input_rate = INPUT_RATE_DEFAULT;
452
453     return 0;
454 }
455
456 /*****************************************************************************
457  * aout_InputDelete : delete an input
458  *****************************************************************************
459  * This function must be entered with the mixer lock.
460  *****************************************************************************/
461 int aout_InputDelete( aout_instance_t * p_aout, aout_input_t * p_input )
462 {
463     AOUT_ASSERT_MIXER_LOCKED;
464     if ( p_input->b_error ) return 0;
465
466     aout_FiltersDestroyPipeline( p_aout, p_input->pp_filters,
467                                  p_input->i_nb_filters );
468     p_input->i_nb_filters = 0;
469     aout_FiltersDestroyPipeline( p_aout, p_input->pp_resamplers,
470                                  p_input->i_nb_resamplers );
471     p_input->i_nb_resamplers = 0;
472     aout_FifoDestroy( p_aout, &p_input->fifo );
473
474     return 0;
475 }
476
477 /*****************************************************************************
478  * aout_InputPlay : play a buffer
479  *****************************************************************************
480  * This function must be entered with the input lock.
481  *****************************************************************************/
482 /* XXX Do not activate it !! */
483 //#define AOUT_PROCESS_BEFORE_CHEKS
484 int aout_InputPlay( aout_instance_t * p_aout, aout_input_t * p_input,
485                     aout_buffer_t * p_buffer, int i_input_rate )
486 {
487     mtime_t start_date;
488     AOUT_ASSERT_INPUT_LOCKED;
489
490     if( p_input->b_restart )
491     {
492         aout_fifo_t fifo, dummy_fifo;
493         uint8_t     *p_first_byte_to_mix;
494
495         aout_lock_mixer( p_aout );
496         aout_lock_input_fifos( p_aout );
497
498         /* A little trick to avoid loosing our input fifo */
499         aout_FifoInit( p_aout, &dummy_fifo, p_aout->mixer.mixer.i_rate );
500         p_first_byte_to_mix = p_input->p_first_byte_to_mix;
501         fifo = p_input->fifo;
502         p_input->fifo = dummy_fifo;
503         aout_InputDelete( p_aout, p_input );
504         aout_InputNew( p_aout, p_input );
505         p_input->p_first_byte_to_mix = p_first_byte_to_mix;
506         p_input->fifo = fifo;
507
508         aout_unlock_input_fifos( p_aout );
509         aout_unlock_mixer( p_aout );
510     }
511
512     if( i_input_rate != INPUT_RATE_DEFAULT && p_input->p_playback_rate_filter == NULL )
513     {
514         inputDrop( p_aout, p_input, p_buffer );
515         return 0;
516     }
517
518 #ifdef AOUT_PROCESS_BEFORE_CHEKS
519     /* Run pre-filters. */
520     aout_FiltersPlay( p_aout, p_input->pp_filters, p_input->i_nb_filters,
521                       &p_buffer );
522
523     /* Actually run the resampler now. */
524     if ( p_input->i_nb_resamplers > 0 )
525     {
526         const mtime_t i_date = p_buffer->start_date;
527         aout_FiltersPlay( p_aout, p_input->pp_resamplers,
528                           p_input->i_nb_resamplers,
529                           &p_buffer );
530     }
531
532     if( p_buffer->i_nb_samples <= 0 )
533     {
534         aout_BufferFree( p_buffer );
535         return 0;
536     }
537 #endif
538
539     /* Handle input rate change, but keep drift correction */
540     if( i_input_rate != p_input->i_last_input_rate )
541     {
542         unsigned int * const pi_rate = &p_input->p_playback_rate_filter->input.i_rate;
543 #define F(r,ir) ( INPUT_RATE_DEFAULT * (r) / (ir) )
544         const int i_delta = *pi_rate - F(p_input->input.i_rate,p_input->i_last_input_rate);
545         *pi_rate = F(p_input->input.i_rate + i_delta, i_input_rate);
546 #undef F
547         p_input->i_last_input_rate = i_input_rate;
548     }
549
550     /* We don't care if someone changes the start date behind our back after
551      * this. We'll deal with that when pushing the buffer, and compensate
552      * with the next incoming buffer. */
553     aout_lock_input_fifos( p_aout );
554     start_date = aout_FifoNextStart( p_aout, &p_input->fifo );
555     aout_unlock_input_fifos( p_aout );
556
557     if ( start_date != 0 && start_date < mdate() )
558     {
559         /* The decoder is _very_ late. This can only happen if the user
560          * pauses the stream (or if the decoder is buggy, which cannot
561          * happen :). */
562         msg_Warn( p_aout, "computed PTS is out of range (%"PRId64"), "
563                   "clearing out", mdate() - start_date );
564         aout_lock_input_fifos( p_aout );
565         aout_FifoSet( p_aout, &p_input->fifo, 0 );
566         p_input->p_first_byte_to_mix = NULL;
567         aout_unlock_input_fifos( p_aout );
568         if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
569             msg_Warn( p_aout, "timing screwed, stopping resampling" );
570         inputResamplingStop( p_input );
571         start_date = 0;
572     }
573
574     if ( p_buffer->start_date < mdate() + AOUT_MIN_PREPARE_TIME )
575     {
576         /* The decoder gives us f*cked up PTS. It's its business, but we
577          * can't present it anyway, so drop the buffer. */
578         msg_Warn( p_aout, "PTS is out of range (%"PRId64"), dropping buffer",
579                   mdate() - p_buffer->start_date );
580
581         inputDrop( p_aout, p_input, p_buffer );
582         inputResamplingStop( p_input );
583         return 0;
584     }
585
586     /* If the audio drift is too big then it's not worth trying to resample
587      * the audio. */
588     mtime_t i_pts_tolerance = 3 * AOUT_PTS_TOLERANCE * i_input_rate / INPUT_RATE_DEFAULT;
589     if ( start_date != 0 &&
590          ( start_date < p_buffer->start_date - i_pts_tolerance ) )
591     {
592         msg_Warn( p_aout, "audio drift is too big (%"PRId64"), clearing out",
593                   start_date - p_buffer->start_date );
594         aout_lock_input_fifos( p_aout );
595         aout_FifoSet( p_aout, &p_input->fifo, 0 );
596         p_input->p_first_byte_to_mix = NULL;
597         aout_unlock_input_fifos( p_aout );
598         if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
599             msg_Warn( p_aout, "timing screwed, stopping resampling" );
600         inputResamplingStop( p_input );
601         start_date = 0;
602     }
603     else if ( start_date != 0 &&
604               ( start_date > p_buffer->start_date + i_pts_tolerance) )
605     {
606         msg_Warn( p_aout, "audio drift is too big (%"PRId64"), dropping buffer",
607                   start_date - p_buffer->start_date );
608         inputDrop( p_aout, p_input, p_buffer );
609         return 0;
610     }
611
612     if ( start_date == 0 ) start_date = p_buffer->start_date;
613
614 #ifndef AOUT_PROCESS_BEFORE_CHEKS
615     /* Run pre-filters. */
616     aout_FiltersPlay( p_aout, p_input->pp_filters, p_input->i_nb_filters,
617                       &p_buffer );
618 #endif
619
620     /* Run the resampler if needed.
621      * We first need to calculate the output rate of this resampler. */
622     if ( ( p_input->i_resampling_type == AOUT_RESAMPLING_NONE ) &&
623          ( start_date < p_buffer->start_date - AOUT_PTS_TOLERANCE
624            || start_date > p_buffer->start_date + AOUT_PTS_TOLERANCE ) &&
625          p_input->i_nb_resamplers > 0 )
626     {
627         /* Can happen in several circumstances :
628          * 1. A problem at the input (clock drift)
629          * 2. A small pause triggered by the user
630          * 3. Some delay in the output stage, causing a loss of lip
631          *    synchronization
632          * Solution : resample the buffer to avoid a scratch.
633          */
634         mtime_t drift = p_buffer->start_date - start_date;
635
636         p_input->i_resamp_start_date = mdate();
637         p_input->i_resamp_start_drift = (int)drift;
638
639         if ( drift > 0 )
640             p_input->i_resampling_type = AOUT_RESAMPLING_DOWN;
641         else
642             p_input->i_resampling_type = AOUT_RESAMPLING_UP;
643
644         msg_Warn( p_aout, "buffer is %"PRId64" %s, triggering %ssampling",
645                           drift > 0 ? drift : -drift,
646                           drift > 0 ? "in advance" : "late",
647                           drift > 0 ? "down" : "up");
648     }
649
650     if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
651     {
652         /* Resampling has been triggered previously (because of dates
653          * mismatch). We want the resampling to happen progressively so
654          * it isn't too audible to the listener. */
655
656         if( p_input->i_resampling_type == AOUT_RESAMPLING_UP )
657         {
658             p_input->pp_resamplers[0]->input.i_rate += 2; /* Hz */
659         }
660         else
661         {
662             p_input->pp_resamplers[0]->input.i_rate -= 2; /* Hz */
663         }
664
665         /* Check if everything is back to normal, in which case we can stop the
666          * resampling */
667         unsigned int i_nominal_rate =
668           (p_input->pp_resamplers[0] == p_input->p_playback_rate_filter)
669           ? INPUT_RATE_DEFAULT * p_input->input.i_rate / i_input_rate
670           : p_input->input.i_rate;
671         if( p_input->pp_resamplers[0]->input.i_rate == i_nominal_rate )
672         {
673             p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
674             msg_Warn( p_aout, "resampling stopped after %"PRIi64" usec "
675                       "(drift: %"PRIi64")",
676                       mdate() - p_input->i_resamp_start_date,
677                       p_buffer->start_date - start_date);
678         }
679         else if( abs( (int)(p_buffer->start_date - start_date) ) <
680                  abs( p_input->i_resamp_start_drift ) / 2 )
681         {
682             /* if we reduced the drift from half, then it is time to switch
683              * back the resampling direction. */
684             if( p_input->i_resampling_type == AOUT_RESAMPLING_UP )
685                 p_input->i_resampling_type = AOUT_RESAMPLING_DOWN;
686             else
687                 p_input->i_resampling_type = AOUT_RESAMPLING_UP;
688             p_input->i_resamp_start_drift = 0;
689         }
690         else if( p_input->i_resamp_start_drift &&
691                  ( abs( (int)(p_buffer->start_date - start_date) ) >
692                    abs( p_input->i_resamp_start_drift ) * 3 / 2 ) )
693         {
694             /* If the drift is increasing and not decreasing, than something
695              * is bad. We'd better stop the resampling right now. */
696             msg_Warn( p_aout, "timing screwed, stopping resampling" );
697             inputResamplingStop( p_input );
698         }
699     }
700
701 #ifndef AOUT_PROCESS_BEFORE_CHEKS
702     /* Actually run the resampler now. */
703     if ( p_input->i_nb_resamplers > 0 )
704     {
705         aout_FiltersPlay( p_aout, p_input->pp_resamplers,
706                           p_input->i_nb_resamplers,
707                           &p_buffer );
708     }
709
710     if( p_buffer->i_nb_samples <= 0 )
711     {
712         aout_BufferFree( p_buffer );
713         return 0;
714     }
715 #endif
716
717     /* Adding the start date will be managed by aout_FifoPush(). */
718     p_buffer->end_date = start_date +
719         (p_buffer->end_date - p_buffer->start_date);
720     p_buffer->start_date = start_date;
721
722     aout_lock_input_fifos( p_aout );
723     aout_FifoPush( p_aout, &p_input->fifo, p_buffer );
724     aout_unlock_input_fifos( p_aout );
725     return 0;
726 }
727
728 /*****************************************************************************
729  * static functions
730  *****************************************************************************/
731
732 static void inputFailure( aout_instance_t * p_aout, aout_input_t * p_input,
733                           const char * psz_error_message )
734 {
735     /* error message */
736     msg_Err( p_aout, "%s", psz_error_message );
737
738     /* clean up */
739     aout_FiltersDestroyPipeline( p_aout, p_input->pp_filters,
740                                  p_input->i_nb_filters );
741     aout_FiltersDestroyPipeline( p_aout, p_input->pp_resamplers,
742                                  p_input->i_nb_resamplers );
743     aout_FifoDestroy( p_aout, &p_input->fifo );
744     var_Destroy( p_aout, "visual" );
745     var_Destroy( p_aout, "equalizer" );
746     var_Destroy( p_aout, "audio-filter" );
747     var_Destroy( p_aout, "audio-visual" );
748
749     var_Destroy( p_aout, "audio-replay-gain-mode" );
750     var_Destroy( p_aout, "audio-replay-gain-default" );
751     var_Destroy( p_aout, "audio-replay-gain-preamp" );
752     var_Destroy( p_aout, "audio-replay-gain-peak-protection" );
753
754     /* error flag */
755     p_input->b_error = 1;
756 }
757
758 static void inputDrop( aout_instance_t *p_aout, aout_input_t *p_input, aout_buffer_t *p_buffer )
759 {
760     aout_BufferFree( p_buffer );
761
762     if( !p_input->p_input_thread )
763         return;
764
765     vlc_mutex_lock( &p_input->p_input_thread->p->counters.counters_lock);
766     stats_UpdateInteger( p_aout, p_input->p_input_thread->p->counters.p_lost_abuffers, 1, NULL );
767     vlc_mutex_unlock( &p_input->p_input_thread->p->counters.counters_lock);
768 }
769
770 static void inputResamplingStop( aout_input_t *p_input )
771 {
772     p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
773     if( p_input->i_nb_resamplers != 0 )
774     {
775         p_input->pp_resamplers[0]->input.i_rate =
776             ( p_input->pp_resamplers[0] == p_input->p_playback_rate_filter )
777             ? INPUT_RATE_DEFAULT * p_input->input.i_rate / p_input->i_last_input_rate
778             : p_input->input.i_rate;
779         p_input->pp_resamplers[0]->b_continuity = false;
780     }
781 }
782
783 static int ChangeFiltersString( aout_instance_t * p_aout, const char* psz_variable,
784                                  const char *psz_name, bool b_add )
785 {
786     return AoutChangeFilterString( VLC_OBJECT(p_aout), p_aout,
787                                    psz_variable, psz_name, b_add ) ? 1 : 0;
788 }
789
790 static int VisualizationCallback( vlc_object_t *p_this, char const *psz_cmd,
791                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
792 {
793     aout_instance_t *p_aout = (aout_instance_t *)p_this;
794     char *psz_mode = newval.psz_string;
795     vlc_value_t val;
796     (void)psz_cmd; (void)oldval; (void)p_data;
797
798     if( !psz_mode || !*psz_mode )
799     {
800         ChangeFiltersString( p_aout, "audio-visual", "goom", false );
801         ChangeFiltersString( p_aout, "audio-visual", "visual", false );
802         ChangeFiltersString( p_aout, "audio-visual", "galaktos", false );
803     }
804     else
805     {
806         if( !strcmp( "goom", psz_mode ) )
807         {
808             ChangeFiltersString( p_aout, "audio-visual", "visual", false );
809             ChangeFiltersString( p_aout, "audio-visual", "goom", true );
810             ChangeFiltersString( p_aout, "audio-visual", "galaktos", false);
811         }
812         else if( !strcmp( "galaktos", psz_mode ) )
813         {
814             ChangeFiltersString( p_aout, "audio-visual", "visual", false );
815             ChangeFiltersString( p_aout, "audio-visual", "goom", false );
816             ChangeFiltersString( p_aout, "audio-visual", "galaktos", true );
817         }
818         else
819         {
820             val.psz_string = psz_mode;
821             var_Create( p_aout, "effect-list", VLC_VAR_STRING );
822             var_Set( p_aout, "effect-list", val );
823
824             ChangeFiltersString( p_aout, "audio-visual", "goom", false );
825             ChangeFiltersString( p_aout, "audio-visual", "visual", true );
826             ChangeFiltersString( p_aout, "audio-visual", "galaktos", false);
827         }
828     }
829
830     /* That sucks */
831     AoutInputsMarkToRestart( p_aout );
832
833     return VLC_SUCCESS;
834 }
835
836 static int EqualizerCallback( vlc_object_t *p_this, char const *psz_cmd,
837                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
838 {
839     aout_instance_t *p_aout = (aout_instance_t *)p_this;
840     char *psz_mode = newval.psz_string;
841     vlc_value_t val;
842     int i_ret;
843     (void)psz_cmd; (void)oldval; (void)p_data;
844
845     if( !psz_mode || !*psz_mode )
846     {
847         i_ret = ChangeFiltersString( p_aout, "audio-filter", "equalizer",
848                                      false );
849     }
850     else
851     {
852         val.psz_string = psz_mode;
853         var_Create( p_aout, "equalizer-preset", VLC_VAR_STRING );
854         var_Set( p_aout, "equalizer-preset", val );
855         i_ret = ChangeFiltersString( p_aout, "audio-filter", "equalizer",
856                                      true );
857
858     }
859
860     /* That sucks */
861     if( i_ret == 1 )
862         AoutInputsMarkToRestart( p_aout );
863     return VLC_SUCCESS;
864 }
865
866 static int ReplayGainCallback( vlc_object_t *p_this, char const *psz_cmd,
867                                vlc_value_t oldval, vlc_value_t newval, void *p_data )
868 {
869     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
870     VLC_UNUSED(newval); VLC_UNUSED(p_data);
871     aout_instance_t *p_aout = (aout_instance_t *)p_this;
872     int i;
873
874     aout_lock_mixer( p_aout );
875     for( i = 0; i < p_aout->i_nb_inputs; i++ )
876         ReplayGainSelect( p_aout, p_aout->pp_inputs[i] );
877
878     /* Restart the mixer (a trivial mixer may be in use) */
879     aout_MixerMultiplierSet( p_aout, p_aout->mixer.f_multiplier );
880     aout_unlock_mixer( p_aout );
881
882     return VLC_SUCCESS;
883 }
884
885 static void ReplayGainSelect( aout_instance_t *p_aout, aout_input_t *p_input )
886 {
887     char *psz_replay_gain = var_GetNonEmptyString( p_aout,
888                                                    "audio-replay-gain-mode" );
889     int i_mode;
890     int i_use;
891     float f_gain;
892
893     p_input->f_multiplier = 1.0;
894
895     if( !psz_replay_gain )
896         return;
897
898     /* Find select mode */
899     if( !strcmp( psz_replay_gain, "track" ) )
900         i_mode = AUDIO_REPLAY_GAIN_TRACK;
901     else if( !strcmp( psz_replay_gain, "album" ) )
902         i_mode = AUDIO_REPLAY_GAIN_ALBUM;
903     else
904         i_mode = AUDIO_REPLAY_GAIN_MAX;
905
906     /* If the select mode is not available, prefer the other one */
907     i_use = i_mode;
908     if( i_use != AUDIO_REPLAY_GAIN_MAX && !p_input->replay_gain.pb_gain[i_use] )
909     {
910         for( i_use = 0; i_use < AUDIO_REPLAY_GAIN_MAX; i_use++ )
911         {
912             if( p_input->replay_gain.pb_gain[i_use] )
913                 break;
914         }
915     }
916
917     /* */
918     if( i_use != AUDIO_REPLAY_GAIN_MAX )
919         f_gain = p_input->replay_gain.pf_gain[i_use] + var_GetFloat( p_aout, "audio-replay-gain-preamp" );
920     else if( i_mode != AUDIO_REPLAY_GAIN_MAX )
921         f_gain = var_GetFloat( p_aout, "audio-replay-gain-default" );
922     else
923         f_gain = 0.0;
924     p_input->f_multiplier = pow( 10.0, f_gain / 20.0 );
925
926     /* */
927     if( p_input->replay_gain.pb_peak[i_use] &&
928         var_GetBool( p_aout, "audio-replay-gain-peak-protection" ) &&
929         p_input->replay_gain.pf_peak[i_use] * p_input->f_multiplier > 1.0 )
930     {
931         p_input->f_multiplier = 1.0f / p_input->replay_gain.pf_peak[i_use];
932     }
933
934     free( psz_replay_gain );
935 }
936