src/audio_output/input.c

   1 /*****************************************************************************
   2  * input.c : internal management of input streams for the audio output
   3  *****************************************************************************
   4  * Copyright (C) 2002-2007 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * 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 <assert.h>
  37
  38 #include <vlc_input.h>
  39 #include <vlc_vout.h>                  /* for vout_Request */
  40 #include <vlc_modules.h>
  41 #include <vlc_aout.h>
  42 #include <vlc_filter.h>
  43 #include <libvlc.h>
  44
  45 #include "aout_internal.h"
  46
  47 static void inputDrop( aout_input_t *, aout_buffer_t * );
  48 static void inputResamplingStop( aout_input_t *p_input );
  49
  50 static int VisualizationCallback( vlc_object_t *, char const *,
  51                                   vlc_value_t, vlc_value_t, void * );
  52 static int EqualizerCallback( vlc_object_t *, char const *,
  53                               vlc_value_t, vlc_value_t, void * );
  54
  55 static vout_thread_t *RequestVout( void *,
  56                                    vout_thread_t *, video_format_t *, bool );
  57
  58 /*****************************************************************************
  59  * aout_InputNew : allocate a new input and rework the filter pipeline
  60  *****************************************************************************/
  61 aout_input_t *aout_InputNew (audio_output_t * p_aout,
  62                              const audio_sample_format_t *restrict infmt,
  63                              const audio_sample_format_t *restrict outfmt,
  64                              const aout_request_vout_t *p_request_vout)
  65 {
  66     aout_input_t *p_input = malloc (sizeof (*p_input));
  67     if (unlikely(p_input == NULL))
  68         return NULL;
  69
  70     aout_FormatPrint( p_aout, "input", infmt );
  71     p_input->samplerate = infmt->i_rate;
  72
  73     p_input->i_nb_resamplers = p_input->i_nb_filters = 0;
  74
  75     /* */
  76     if( p_request_vout )
  77     {
  78         p_input->request_vout = *p_request_vout;
  79     }
  80     else
  81     {
  82         p_input->request_vout.pf_request_vout = RequestVout;
  83         p_input->request_vout.p_private = p_aout;
  84     }
  85
  86     /* Prepare format structure */
  87     audio_sample_format_t chain_input_format = *infmt;
  88     audio_sample_format_t chain_output_format = *outfmt;
  89
  90     chain_output_format.i_rate = infmt->i_rate;
  91     aout_FormatPrepare( &chain_output_format );
  92
  93     /* Now add user filters */
  94     var_AddCallback( p_aout, "visual", VisualizationCallback, p_input );
  95     var_AddCallback( p_aout, "equalizer", EqualizerCallback, p_input );
  96
  97     char *psz_filters = var_GetString( p_aout, "audio-filter" );
  98     char *psz_visual = var_GetString( p_aout, "audio-visual");
  99     char *psz_scaletempo = var_InheritBool( p_aout, "audio-time-stretch" ) ? strdup( "scaletempo" ) : NULL;
 100
 101     p_input->b_recycle_vout = psz_visual && *psz_visual;
 102
 103     /* parse user filter lists */
 104     char *const ppsz_array[] = { psz_scaletempo, psz_filters, psz_visual };
 105     p_input->p_playback_rate_filter = NULL;
 106
 107     for (unsigned i_visual = 0;
 108          i_visual < 3 && AOUT_FMT_LINEAR(&chain_output_format);
 109          i_visual++)
 110     {
 111         char *psz_next = NULL;
 112         char *psz_parser = ppsz_array[i_visual];
 113
 114         if( psz_parser == NULL || !*psz_parser )
 115             continue;
 116
 117         while( psz_parser && *psz_parser )
 118         {
 119             filter_t * p_filter = NULL;
 120
 121             if( p_input->i_nb_filters >= AOUT_MAX_FILTERS )
 122             {
 123                 msg_Dbg( p_aout, "max filters reached (%d)", AOUT_MAX_FILTERS );
 124                 break;
 125             }
 126
 127             while( *psz_parser == ' ' && *psz_parser == ':' )
 128             {
 129                 psz_parser++;
 130             }
 131             if( ( psz_next = strchr( psz_parser , ':'  ) ) )
 132             {
 133                 *psz_next++ = '\0';
 134             }
 135             if( *psz_parser =='\0' )
 136             {
 137                 break;
 138             }
 139
 140             /* Create a VLC object */
 141             p_filter = vlc_custom_create( p_aout, sizeof(*p_filter),
 142                                           "audio filter" );
 143             if( p_filter == NULL )
 144             {
 145                 msg_Err( p_aout, "cannot add user filter %s (skipped)",
 146                          psz_parser );
 147                 psz_parser = psz_next;
 148                 continue;
 149             }
 150
 151             p_filter->p_owner = malloc( sizeof(*p_filter->p_owner) );
 152             p_filter->p_owner->p_aout  = p_aout;
 153             p_filter->p_owner->p_input = p_input;
 154
 155             /* request format */
 156             memcpy( &p_filter->fmt_in.audio, &chain_output_format,
 157                     sizeof(audio_sample_format_t) );
 158             p_filter->fmt_in.i_codec = chain_output_format.i_format;
 159             memcpy( &p_filter->fmt_out.audio, &chain_output_format,
 160                     sizeof(audio_sample_format_t) );
 161             p_filter->fmt_out.i_codec = chain_output_format.i_format;
 162
 163             /* try to find the requested filter */
 164             if( i_visual == 2 ) /* this can only be a visualization module */
 165             {
 166                 p_filter->p_module = module_need( p_filter, "visualization2",
 167                                                   psz_parser, true );
 168             }
 169             else /* this can be a audio filter module as well as a visualization module */
 170             {
 171                 p_filter->p_module = module_need( p_filter, "audio filter",
 172                                               psz_parser, true );
 173
 174                 if ( p_filter->p_module == NULL )
 175                 {
 176                     /* if the filter requested a special format, retry */
 177                     if ( !( AOUT_FMTS_IDENTICAL( &p_filter->fmt_in.audio,
 178                                                  &chain_input_format )
 179                             && AOUT_FMTS_IDENTICAL( &p_filter->fmt_out.audio,
 180                                                     &chain_output_format ) ) )
 181                     {
 182                         aout_FormatPrepare( &p_filter->fmt_in.audio );
 183                         aout_FormatPrepare( &p_filter->fmt_out.audio );
 184                         p_filter->p_module = module_need( p_filter,
 185                                                           "audio filter",
 186                                                           psz_parser, true );
 187                     }
 188                     /* try visual filters */
 189                     else
 190                     {
 191                         memcpy( &p_filter->fmt_in.audio, &chain_output_format,
 192                                 sizeof(audio_sample_format_t) );
 193                         memcpy( &p_filter->fmt_out.audio, &chain_output_format,
 194                                 sizeof(audio_sample_format_t) );
 195                         p_filter->p_module = module_need( p_filter,
 196                                                           "visualization2",
 197                                                           psz_parser, true );
 198                     }
 199                 }
 200             }
 201
 202             /* failure */
 203             if ( p_filter->p_module == NULL )
 204             {
 205                 msg_Err( p_aout, "cannot add user filter %s (skipped)",
 206                          psz_parser );
 207
 208                 free( p_filter->p_owner );
 209                 vlc_object_release( p_filter );
 210
 211                 psz_parser = psz_next;
 212                 continue;
 213             }
 214
 215             /* complete the filter chain if necessary */
 216             if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters,
 217                                              &p_input->i_nb_filters,
 218                                              &chain_input_format,
 219                                              &p_filter->fmt_in.audio ) < 0 )
 220             {
 221                 msg_Err( p_aout, "cannot add user filter %s (skipped)",
 222                          psz_parser );
 223
 224                 module_unneed( p_filter, p_filter->p_module );
 225                 free( p_filter->p_owner );
 226                 vlc_object_release( p_filter );
 227
 228                 psz_parser = psz_next;
 229                 continue;
 230             }
 231
 232             /* success */
 233             p_input->pp_filters[p_input->i_nb_filters++] = p_filter;
 234             memcpy( &chain_input_format, &p_filter->fmt_out.audio,
 235                     sizeof( audio_sample_format_t ) );
 236
 237             if( i_visual == 0 ) /* scaletempo */
 238                 p_input->p_playback_rate_filter = p_filter;
 239
 240             /* next filter if any */
 241             psz_parser = psz_next;
 242         }
 243     }
 244     free( psz_visual );
 245     free( psz_filters );
 246     free( psz_scaletempo );
 247
 248     /* complete the filter chain if necessary */
 249     if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters,
 250                                      &p_input->i_nb_filters,
 251                                      &chain_input_format,
 252                                      &chain_output_format ) < 0 )
 253     {
 254         msg_Err (p_aout, "cannot setup filtering pipeline");
 255         goto error;
 256     }
 257
 258     /* Create resamplers. */
 259     if (AOUT_FMT_LINEAR(outfmt))
 260     {
 261         chain_output_format.i_rate = (__MAX(p_input->samplerate,
 262                                             outfmt->i_rate)
 263                                  * (100 + AOUT_MAX_RESAMPLING)) / 100;
 264         if ( chain_output_format.i_rate == outfmt->i_rate )
 265         {
 266             /* Just in case... */
 267             chain_output_format.i_rate++;
 268         }
 269         if (aout_FiltersCreatePipeline (p_aout, p_input->pp_resamplers,
 270                                         &p_input->i_nb_resamplers,
 271                                         &chain_output_format, outfmt) < 0)
 272         {
 273             msg_Err (p_aout, "cannot setup a resampling pipeline");
 274             goto error;
 275         }
 276
 277         /* Setup the initial rate of the resampler */
 278         p_input->pp_resamplers[0]->fmt_in.audio.i_rate = p_input->samplerate;
 279     }
 280     p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
 281
 282     if( ! p_input->p_playback_rate_filter && p_input->i_nb_resamplers > 0 )
 283     {
 284         p_input->p_playback_rate_filter = p_input->pp_resamplers[0];
 285     }
 286
 287     /* Success */
 288     p_input->i_last_input_rate = INPUT_RATE_DEFAULT;
 289     p_input->i_buffer_lost = 0;
 290     return p_input;
 291
 292 error:
 293     aout_FiltersDestroyPipeline( p_input->pp_filters, p_input->i_nb_filters );
 294     aout_FiltersDestroyPipeline( p_input->pp_resamplers,
 295                                  p_input->i_nb_resamplers );
 296     free (p_input);
 297     return NULL;
 298 }
 299
 300 /*****************************************************************************
 301  * aout_InputDelete : delete an input
 302  *****************************************************************************
 303  * This function must be entered with the mixer lock.
 304  *****************************************************************************/
 305 int aout_InputDelete( audio_output_t * p_aout, aout_input_t * p_input )
 306 {
 307     var_DelCallback (p_aout, "equalizer", EqualizerCallback, p_input);
 308     var_DelCallback (p_aout, "visual", VisualizationCallback, p_input);
 309
 310     /* XXX We need to update b_recycle_vout before calling aout_FiltersDestroyPipeline.
 311      * FIXME They can be a race condition if audio-visual is updated between
 312      * aout_InputDelete and aout_InputNew.
 313      */
 314     char *psz_visual = var_GetString( p_aout, "audio-visual");
 315     p_input->b_recycle_vout = psz_visual && *psz_visual;
 316     free( psz_visual );
 317
 318     aout_FiltersDestroyPipeline( p_input->pp_filters, p_input->i_nb_filters );
 319     p_input->i_nb_filters = 0;
 320     aout_FiltersDestroyPipeline( p_input->pp_resamplers,
 321                                  p_input->i_nb_resamplers );
 322     p_input->i_nb_resamplers = 0;
 323
 324     return 0;
 325 }
 326
 327 /*****************************************************************************
 328  * aout_InputPlay : play a buffer
 329  *****************************************************************************
 330  * This function must be entered with the input lock.
 331  *****************************************************************************/
 332 /* XXX Do not activate it !! */
 333 //#define AOUT_PROCESS_BEFORE_CHEKS
 334 block_t *aout_InputPlay(audio_output_t *p_aout, aout_input_t *p_input,
 335                         block_t *p_buffer, int i_input_rate, date_t *date )
 336 {
 337     mtime_t start_date;
 338
 339     aout_assert_locked( p_aout );
 340
 341     if( i_input_rate != INPUT_RATE_DEFAULT && p_input->p_playback_rate_filter == NULL )
 342     {
 343         inputDrop( p_input, p_buffer );
 344         return NULL;
 345     }
 346
 347 #ifdef AOUT_PROCESS_BEFORE_CHEKS
 348     /* Run pre-filters. */
 349     aout_FiltersPlay( p_aout, p_input->pp_filters, p_input->i_nb_filters,
 350                       &p_buffer );
 351     if( !p_buffer )
 352         return NULL;
 353
 354     /* Actually run the resampler now. */
 355     if ( p_input->i_nb_resamplers > 0 )
 356     {
 357         const mtime_t i_date = p_buffer->i_pts;
 358         aout_FiltersPlay( p_aout, p_input->pp_resamplers,
 359                           p_input->i_nb_resamplers,
 360                           &p_buffer );
 361     }
 362
 363     if( !p_buffer )
 364         return NULL;
 365     if( p_buffer->i_nb_samples <= 0 )
 366     {
 367         block_Release( p_buffer );
 368         return NULL;
 369     }
 370 #endif
 371
 372     /* Handle input rate change, but keep drift correction */
 373     if( i_input_rate != p_input->i_last_input_rate )
 374     {
 375         unsigned int * const pi_rate = &p_input->p_playback_rate_filter->fmt_in.audio.i_rate;
 376 #define F(r,ir) ( INPUT_RATE_DEFAULT * (r) / (ir) )
 377         const int i_delta = *pi_rate - F(p_input->samplerate,p_input->i_last_input_rate);
 378         *pi_rate = F(p_input->samplerate + i_delta, i_input_rate);
 379 #undef F
 380         p_input->i_last_input_rate = i_input_rate;
 381     }
 382
 383     mtime_t now = mdate();
 384
 385     /* We don't care if someone changes the start date behind our back after
 386      * this. We'll deal with that when pushing the buffer, and compensate
 387      * with the next incoming buffer. */
 388     start_date = date_Get (date);
 389
 390     if ( start_date != VLC_TS_INVALID && start_date < now )
 391     {
 392         /* The decoder is _very_ late. This can only happen if the user
 393          * pauses the stream (or if the decoder is buggy, which cannot
 394          * happen :). */
 395         msg_Warn( p_aout, "computed PTS is out of range (%"PRId64"), "
 396                   "clearing out", now - start_date );
 397         aout_OutputFlush( p_aout, false );
 398         if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
 399             msg_Warn( p_aout, "timing screwed, stopping resampling" );
 400         inputResamplingStop( p_input );
 401         p_buffer->i_flags |= BLOCK_FLAG_DISCONTINUITY;
 402         start_date = VLC_TS_INVALID;
 403     }
 404
 405     if ( p_buffer->i_pts < now + AOUT_MIN_PREPARE_TIME )
 406     {
 407         /* The decoder gives us f*cked up PTS. It's its business, but we
 408          * can't present it anyway, so drop the buffer. */
 409         msg_Warn( p_aout, "PTS is out of range (%"PRId64"), dropping buffer",
 410                   now - p_buffer->i_pts );
 411         inputDrop( p_input, p_buffer );
 412         inputResamplingStop( p_input );
 413         return NULL;
 414     }
 415
 416     /* If the audio drift is too big then it's not worth trying to resample
 417      * the audio. */
 418     if( start_date == VLC_TS_INVALID )
 419     {
 420         start_date = p_buffer->i_pts;
 421         date_Set (date, start_date);
 422     }
 423
 424     mtime_t drift = start_date - p_buffer->i_pts;
 425
 426     if( drift < -i_input_rate * 3 * AOUT_MAX_PTS_ADVANCE / INPUT_RATE_DEFAULT )
 427     {
 428         msg_Warn( p_aout, "buffer way too early (%"PRId64"), clearing queue",
 429                   drift );
 430         aout_OutputFlush( p_aout, false );
 431         if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
 432             msg_Warn( p_aout, "timing screwed, stopping resampling" );
 433         inputResamplingStop( p_input );
 434         p_buffer->i_flags |= BLOCK_FLAG_DISCONTINUITY;
 435         start_date = p_buffer->i_pts;
 436         date_Set (date, start_date);
 437         drift = 0;
 438     }
 439     else
 440     if( drift > +i_input_rate * 3 * AOUT_MAX_PTS_DELAY / INPUT_RATE_DEFAULT )
 441     {
 442         msg_Warn( p_aout, "buffer way too late (%"PRId64"), dropping buffer",
 443                   drift );
 444         inputDrop( p_input, p_buffer );
 445         return NULL;
 446     }
 447
 448 #ifndef AOUT_PROCESS_BEFORE_CHEKS
 449     /* Run pre-filters. */
 450     aout_FiltersPlay( p_input->pp_filters, p_input->i_nb_filters, &p_buffer );
 451     if( !p_buffer )
 452         return NULL;
 453 #endif
 454
 455     /* Run the resampler if needed.
 456      * We first need to calculate the output rate of this resampler. */
 457     if ( ( p_input->i_resampling_type == AOUT_RESAMPLING_NONE ) &&
 458          ( drift < -AOUT_MAX_PTS_ADVANCE || drift > +AOUT_MAX_PTS_DELAY ) &&
 459          p_input->i_nb_resamplers > 0 )
 460     {
 461         /* Can happen in several circumstances :
 462          * 1. A problem at the input (clock drift)
 463          * 2. A small pause triggered by the user
 464          * 3. Some delay in the output stage, causing a loss of lip
 465          *    synchronization
 466          * Solution : resample the buffer to avoid a scratch.
 467          */
 468         p_input->i_resamp_start_date = now;
 469         p_input->i_resamp_start_drift = (int)-drift;
 470         p_input->i_resampling_type = (drift < 0) ? AOUT_RESAMPLING_DOWN
 471                                                  : AOUT_RESAMPLING_UP;
 472         msg_Warn( p_aout, (drift < 0)
 473                   ? "buffer too early (%"PRId64"), down-sampling"
 474                   : "buffer too late  (%"PRId64"), up-sampling", drift );
 475     }
 476
 477     if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
 478     {
 479         /* Resampling has been triggered previously (because of dates
 480          * mismatch). We want the resampling to happen progressively so
 481          * it isn't too audible to the listener. */
 482
 483         if( p_input->i_resampling_type == AOUT_RESAMPLING_UP )
 484             p_input->pp_resamplers[0]->fmt_in.audio.i_rate += 2; /* Hz */
 485         else
 486             p_input->pp_resamplers[0]->fmt_in.audio.i_rate -= 2; /* Hz */
 487
 488         /* Check if everything is back to normal, in which case we can stop the
 489          * resampling */
 490         unsigned int i_nominal_rate =
 491           (p_input->pp_resamplers[0] == p_input->p_playback_rate_filter)
 492           ? INPUT_RATE_DEFAULT * p_input->samplerate / i_input_rate
 493           : p_input->samplerate;
 494         if( p_input->pp_resamplers[0]->fmt_in.audio.i_rate == i_nominal_rate )
 495         {
 496             p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
 497             msg_Warn( p_aout, "resampling stopped after %"PRIi64" usec "
 498                       "(drift: %"PRIi64")",
 499                       now - p_input->i_resamp_start_date,
 500                       p_buffer->i_pts - start_date);
 501         }
 502         else if( abs( (int)(p_buffer->i_pts - start_date) ) <
 503                  abs( p_input->i_resamp_start_drift ) / 2 )
 504         {
 505             /* if we reduced the drift from half, then it is time to switch
 506              * back the resampling direction. */
 507             if( p_input->i_resampling_type == AOUT_RESAMPLING_UP )
 508                 p_input->i_resampling_type = AOUT_RESAMPLING_DOWN;
 509             else
 510                 p_input->i_resampling_type = AOUT_RESAMPLING_UP;
 511             p_input->i_resamp_start_drift = 0;
 512         }
 513         else if( p_input->i_resamp_start_drift &&
 514                  ( abs( (int)(p_buffer->i_pts - start_date) ) >
 515                    abs( p_input->i_resamp_start_drift ) * 3 / 2 ) )
 516         {
 517             /* If the drift is increasing and not decreasing, than something
 518              * is bad. We'd better stop the resampling right now. */
 519             msg_Warn( p_aout, "timing screwed, stopping resampling" );
 520             inputResamplingStop( p_input );
 521             p_buffer->i_flags |= BLOCK_FLAG_DISCONTINUITY;
 522         }
 523     }
 524
 525 #ifndef AOUT_PROCESS_BEFORE_CHEKS
 526     /* Actually run the resampler now. */
 527     if ( p_input->i_nb_resamplers > 0 )
 528     {
 529         aout_FiltersPlay( p_input->pp_resamplers, p_input->i_nb_resamplers,
 530                           &p_buffer );
 531     }
 532
 533     if( !p_buffer )
 534         return NULL;
 535     if( p_buffer->i_nb_samples <= 0 )
 536     {
 537         block_Release( p_buffer );
 538         return NULL;
 539     }
 540 #endif
 541
 542     p_buffer->i_pts = start_date;
 543     return p_buffer;
 544 }
 545
 546 /*****************************************************************************
 547  * static functions
 548  *****************************************************************************/
 549
 550 static void inputDrop( aout_input_t *p_input, aout_buffer_t *p_buffer )
 551 {
 552     aout_BufferFree( p_buffer );
 553
 554     p_input->i_buffer_lost++;
 555 }
 556
 557 static void inputResamplingStop( aout_input_t *p_input )
 558 {
 559     p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
 560     if( p_input->i_nb_resamplers != 0 )
 561     {
 562         p_input->pp_resamplers[0]->fmt_in.audio.i_rate =
 563             ( p_input->pp_resamplers[0] == p_input->p_playback_rate_filter )
 564             ? INPUT_RATE_DEFAULT * p_input->samplerate / p_input->i_last_input_rate
 565             : p_input->samplerate;
 566     }
 567 }
 568
 569 static vout_thread_t *RequestVout( void *p_private,
 570                                    vout_thread_t *p_vout, video_format_t *p_fmt, bool b_recycle )
 571 {
 572     audio_output_t *p_aout = p_private;
 573     VLC_UNUSED(b_recycle);
 574     vout_configuration_t cfg = {
 575         .vout       = p_vout,
 576         .input      = NULL,
 577         .change_fmt = true,
 578         .fmt        = p_fmt,
 579         .dpb_size   = 1,
 580     };
 581     return vout_Request( p_aout, &cfg );
 582 }
 583
 584 vout_thread_t *aout_filter_RequestVout( filter_t *p_filter,
 585                                         vout_thread_t *p_vout, video_format_t *p_fmt )
 586 {
 587     aout_input_t *p_input = p_filter->p_owner->p_input;
 588     aout_request_vout_t *p_request = &p_input->request_vout;
 589
 590     /* XXX: this only works from audio input */
 591     /* If you want to use visualization filters from another place, you will
 592      * need to add a new pf_aout_request_vout callback or store a pointer
 593      * to aout_request_vout_t inside filter_t (i.e. a level of indirection). */
 594
 595     return p_request->pf_request_vout( p_request->p_private,
 596                                        p_vout, p_fmt, p_input->b_recycle_vout );
 597 }
 598
 599 static inline bool ChangeFiltersString (vlc_object_t *aout, const char *var,
 600                                         const char *filter, bool add)
 601 {
 602     return aout_ChangeFilterString (aout, aout, var, filter, add);
 603 }
 604
 605 static int VisualizationCallback (vlc_object_t *obj, char const *var,
 606                                   vlc_value_t oldval, vlc_value_t newval,
 607                                   void *data)
 608 {
 609     const char *mode = newval.psz_string;
 610     //aout_input_t *input = data;
 611     (void) data;
 612
 613     if (!*mode)
 614     {
 615         ChangeFiltersString (obj, "audio-visual", "goom", false);
 616         ChangeFiltersString (obj, "audio-visual", "visual", false);
 617         ChangeFiltersString (obj, "audio-visual", "projectm", false);
 618     }
 619     else if (!strcmp ("goom", mode))
 620     {
 621         ChangeFiltersString (obj, "audio-visual", "visual", false );
 622         ChangeFiltersString (obj, "audio-visual", "goom", true );
 623         ChangeFiltersString (obj, "audio-visual", "projectm", false );
 624     }
 625     else if (!strcmp ("projectm", mode))
 626     {
 627         ChangeFiltersString (obj, "audio-visual", "visual", false);
 628         ChangeFiltersString (obj, "audio-visual", "goom", false);
 629         ChangeFiltersString (obj, "audio-visual", "projectm", true);
 630     }
 631     else
 632     {
 633         var_Create (obj, "effect-list", VLC_VAR_STRING);
 634         var_SetString (obj, "effect-list", mode);
 635
 636         ChangeFiltersString (obj, "audio-visual", "goom", false);
 637         ChangeFiltersString (obj, "audio-visual", "visual", true);
 638         ChangeFiltersString (obj, "audio-visual", "projectm", false);
 639     }
 640
 641     /* That sucks FIXME: use "input" instead of cast */
 642     aout_InputRequestRestart ((audio_output_t *)obj);
 643
 644     (void) var; (void) oldval;
 645     return VLC_SUCCESS;
 646 }
 647
 648 static int EqualizerCallback (vlc_object_t *obj, char const *cmd,
 649                               vlc_value_t oldval, vlc_value_t newval,
 650                               void *data)
 651 {
 652     char *mode = newval.psz_string;
 653     //aout_input_t *input = data;
 654     bool ret;
 655
 656     (void) data;
 657     (void) cmd; (void) oldval;
 658     if (!*mode)
 659         ret = ChangeFiltersString (obj, "audio-filter", "equalizer", false);
 660     else
 661     {
 662         var_Create (obj, "equalizer-preset", VLC_VAR_STRING);
 663         var_SetString (obj, "equalizer-preset", mode);
 664         ret = ChangeFiltersString (obj, "audio-filter", "equalizer", true);
 665     }
 666
 667     /* That sucks */
 668     if (ret)
 669         aout_InputRequestRestart ((audio_output_t *)obj);
 670     return VLC_SUCCESS;
 671 }