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