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