git.sesse.net Git - vlc/blob - src/audio_output/input.c

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