git.sesse.net Git - vlc/blob - modules/audio_filter/resampler/linear.c

   1 /*****************************************************************************
   2  * linear.c : linear interpolation resampler
   3  *****************************************************************************
   4  * Copyright (C) 2002 VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
   8  *          Sigmund Augdal <sigmunau@idi.ntnu.no>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <stdlib.h>                                      /* malloc(), free() */
  29 #include <string.h>
  30
  31 #include <vlc/vlc.h>
  32 #include "audio_output.h"
  33 #include "aout_internal.h"
  34
  35 /*****************************************************************************
  36  * Local prototypes
  37  *****************************************************************************/
  38 static int  Create    ( vlc_object_t * );
  39 static void Close     ( vlc_object_t * );
  40 static void DoWork    ( aout_instance_t *, aout_filter_t *, aout_buffer_t *,
  41                         aout_buffer_t * );
  42
  43 /*****************************************************************************
  44  * Local structures
  45  *****************************************************************************/
  46 struct aout_filter_sys_t
  47 {
  48     int32_t *p_prev_sample;       /* this filter introduces a 1 sample delay */
  49
  50     unsigned int i_remainder;                /* remainder of previous sample */
  51
  52     audio_date_t end_date;
  53 };
  54
  55 /*****************************************************************************
  56  * Module descriptor
  57  *****************************************************************************/
  58 vlc_module_begin();
  59     set_description( _("audio filter for linear interpolation resampling") );
  60     set_capability( "audio filter", 5 );
  61     set_callbacks( Create, Close );
  62 vlc_module_end();
  63
  64 /*****************************************************************************
  65  * Create: allocate linear resampler
  66  *****************************************************************************/
  67 static int Create( vlc_object_t *p_this )
  68 {
  69     aout_filter_t * p_filter = (aout_filter_t *)p_this;
  70     if ( p_filter->input.i_rate == p_filter->output.i_rate
  71           || p_filter->input.i_format != p_filter->output.i_format
  72           || p_filter->input.i_physical_channels
  73               != p_filter->output.i_physical_channels
  74           || p_filter->input.i_original_channels
  75               != p_filter->output.i_original_channels
  76           || p_filter->input.i_format != VLC_FOURCC('f','l','3','2') )
  77     {
  78         return VLC_EGENERIC;
  79     }
  80
  81     /* Allocate the memory needed to store the module's structure */
  82     p_filter->p_sys = malloc( sizeof(struct aout_filter_sys_t) );
  83     if( p_filter->p_sys == NULL )
  84     {
  85         msg_Err( p_filter, "out of memory" );
  86         return VLC_ENOMEM;
  87     }
  88     p_filter->p_sys->p_prev_sample = malloc(
  89         aout_FormatNbChannels( &p_filter->input ) * sizeof(int32_t) );
  90     if( p_filter->p_sys->p_prev_sample == NULL )
  91     {
  92         msg_Err( p_filter, "out of memory" );
  93         return VLC_ENOMEM;
  94     }
  95
  96     p_filter->pf_do_work = DoWork;
  97
  98     /* We don't want a new buffer to be created because we're not sure we'll
  99      * actually need to resample anything. */
 100     p_filter->b_in_place = VLC_TRUE;
 101
 102     return VLC_SUCCESS;
 103 }
 104
 105 /*****************************************************************************
 106  * Close: free our resources
 107  *****************************************************************************/
 108 static void Close( vlc_object_t * p_this )
 109 {
 110     aout_filter_t * p_filter = (aout_filter_t *)p_this;
 111     free( p_filter->p_sys->p_prev_sample );
 112     free( p_filter->p_sys );
 113 }
 114
 115 /*****************************************************************************
 116  * DoWork: convert a buffer
 117  *****************************************************************************/
 118 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
 119                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
 120 {
 121     float *p_in_orig, *p_in, *p_out = (float *)p_out_buf->p_buffer;
 122     float *p_prev_sample = (float *)p_filter->p_sys->p_prev_sample;
 123
 124     int i_nb_channels = aout_FormatNbChannels( &p_filter->input );
 125     int i_in_nb = p_in_buf->i_nb_samples;
 126     int i_chan, i_in, i_out = 0;
 127
 128     /* Check if we really need to run the resampler */
 129     if( p_aout->mixer.mixer.i_rate == p_filter->input.i_rate )
 130     {
 131         if( p_filter->b_continuity &&
 132             p_in_buf->i_size >=
 133               p_in_buf->i_nb_bytes + sizeof(float) * i_nb_channels )
 134         {
 135             /* output the whole thing with the last sample from last time */
 136             memmove( ((float *)(p_in_buf->p_buffer)) + i_nb_channels,
 137                      p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
 138             memcpy( p_in_buf->p_buffer, p_prev_sample,
 139                     i_nb_channels * sizeof(float) );
 140         }
 141         p_filter->b_continuity = VLC_FALSE;
 142         return;
 143     }
 144
 145 #ifdef HAVE_ALLOCA
 146     p_in = (float *)alloca( p_in_buf->i_nb_bytes );
 147 #else
 148     p_in_orig = p_in = (float *)malloc( p_in_buf->i_nb_bytes );
 149 #endif
 150     if( p_in == NULL )
 151     {
 152         return;
 153     }
 154
 155     p_aout->p_vlc->pf_memcpy( p_in, p_in_buf->p_buffer, p_in_buf->i_nb_bytes );
 156
 157     /* Take care of the previous input sample (if any) */
 158     if( !p_filter->b_continuity )
 159     {
 160         p_filter->b_continuity = VLC_TRUE;
 161         p_filter->p_sys->i_remainder = 0;
 162         aout_DateInit( &p_filter->p_sys->end_date, p_filter->output.i_rate );
 163     }
 164     else
 165     {
 166         while( p_filter->p_sys->i_remainder < p_filter->output.i_rate )
 167         {
 168             for( i_chan = i_nb_channels ; i_chan ; )
 169             {
 170                 i_chan--;
 171                 p_out[i_chan] = p_prev_sample[i_chan];
 172                 p_out[i_chan] += ( (p_prev_sample[i_chan] - p_in[i_chan])
 173                                    * p_filter->p_sys->i_remainder
 174                                    / p_filter->output.i_rate );
 175             }
 176             p_out += i_nb_channels;
 177               i_out++;
 178
 179             p_filter->p_sys->i_remainder += p_filter->input.i_rate;
 180         }
 181         p_filter->p_sys->i_remainder -= p_filter->output.i_rate;
 182     }
 183
 184     /* Take care of the current input samples (minus last one) */
 185     for( i_in = 0; i_in < i_in_nb - 1; i_in++ )
 186     {
 187         while( p_filter->p_sys->i_remainder < p_filter->output.i_rate )
 188         {
 189             for( i_chan = i_nb_channels ; i_chan ; )
 190             {
 191                 i_chan--;
 192                 p_out[i_chan] = p_in[i_chan];
 193                 p_out[i_chan] += ( (p_in[i_chan] -
 194                     p_in[i_chan + i_nb_channels])
 195                     * p_filter->p_sys->i_remainder / p_filter->output.i_rate );
 196             }
 197             p_out += i_nb_channels;
 198               i_out++;
 199
 200             p_filter->p_sys->i_remainder += p_filter->input.i_rate;
 201         }
 202
 203         p_in += i_nb_channels;
 204         p_filter->p_sys->i_remainder -= p_filter->output.i_rate;
 205     }
 206
 207     /* Backup the last input sample for next time */
 208     for( i_chan = i_nb_channels ; i_chan ; )
 209     {
 210         i_chan--;
 211         p_prev_sample[i_chan] = p_in[i_chan];
 212     }
 213
 214     p_out_buf->i_nb_samples = i_out;
 215     p_out_buf->start_date = p_in_buf->start_date;
 216
 217     if( p_in_buf->start_date !=
 218         aout_DateGet( &p_filter->p_sys->end_date ) )
 219     {
 220         aout_DateSet( &p_filter->p_sys->end_date, p_in_buf->start_date );
 221     }
 222
 223     p_out_buf->end_date = aout_DateIncrement( &p_filter->p_sys->end_date,
 224                                               p_out_buf->i_nb_samples );
 225
 226     p_out_buf->i_nb_bytes = p_out_buf->i_nb_samples *
 227         i_nb_channels * sizeof(int32_t);
 228
 229 #ifndef HAVE_ALLOCA
 230     free( p_in_orig );
 231 #endif
 232
 233 }