#include "speex/speex_resampler.h"
#include "arch.h"
#include "os_support.h"
#include "stack_alloc.h"
#include <math.h>
#include <limits.h>

Include dependency graph for resample.c:

Data Structures
struct	FuncDef

struct	QualityMapping

struct	SpeexResamplerState_

Macros
#define	FIXED_STACK_ALLOC 1024

#define	IMAX(a, b) ((a) > (b) ? (a) : (b))

#define	IMIN(a, b) ((a) < (b) ? (a) : (b))

#define	KAISER10 (&_KAISER10)

#define	KAISER12 (&_KAISER12)

#define	KAISER6 (&_KAISER6)

#define	KAISER8 (&_KAISER8)

#define	M_PI 3.14159265358979323846

#define	NULL 0

#define	WORD2INT(x) ((x) < -32767 ? -32768 : ((x) > 32766 ? 32767 : (x)))

Typedefs
typedef int(*	resampler_basic_func) (SpeexResamplerState , spx_uint32_t, const spx_word16_t , spx_uint32_t , spx_word16_t , spx_uint32_t *)

Functions
static double	compute_func (float x, const struct FuncDef *func)

static void	cubic_coef (spx_word16_t x, spx_word16_t interp[4])

static int	resampler_basic_direct_single (SpeexResamplerState st, spx_uint32_t channel_index, const spx_word16_t in, spx_uint32_t in_len, spx_word16_t out, spx_uint32_t *out_len)

static int	resampler_basic_interpolate_single (SpeexResamplerState st, spx_uint32_t channel_index, const spx_word16_t in, spx_uint32_t in_len, spx_word16_t out, spx_uint32_t *out_len)

static int	resampler_basic_zero (SpeexResamplerState st, spx_uint32_t channel_index, const spx_word16_t in, spx_uint32_t in_len, spx_word16_t out, spx_uint32_t *out_len)

static spx_word16_t	sinc (float cutoff, float x, int N, const struct FuncDef *window_func)

EXPORT void	speex_resampler_destroy (SpeexResamplerState *st)

EXPORT int	speex_resampler_get_input_latency (SpeexResamplerState *st)

EXPORT void	speex_resampler_get_input_stride (SpeexResamplerState st, spx_uint32_t stride)

EXPORT int	speex_resampler_get_output_latency (SpeexResamplerState *st)

EXPORT void	speex_resampler_get_output_stride (SpeexResamplerState st, spx_uint32_t stride)

EXPORT void	speex_resampler_get_quality (SpeexResamplerState st, int quality)

EXPORT void	speex_resampler_get_rate (SpeexResamplerState st, spx_uint32_t in_rate, spx_uint32_t *out_rate)

EXPORT void	speex_resampler_get_ratio (SpeexResamplerState st, spx_uint32_t ratio_num, spx_uint32_t *ratio_den)

EXPORT SpeexResamplerState *	speex_resampler_init (spx_uint32_t nb_channels, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int *err)
	Create a new resampler with integer input and output rates. More...

EXPORT SpeexResamplerState *	speex_resampler_init_frac (spx_uint32_t nb_channels, spx_uint32_t ratio_num, spx_uint32_t ratio_den, spx_uint32_t in_rate, spx_uint32_t out_rate, int quality, int *err)

static int	speex_resampler_magic (SpeexResamplerState st, spx_uint32_t channel_index, spx_word16_t *out, spx_uint32_t out_len)

EXPORT int	speex_resampler_process_float (SpeexResamplerState st, spx_uint32_t channel_index, const float in, spx_uint32_t in_len, float out, spx_uint32_t *out_len)

EXPORT int	speex_resampler_process_int (SpeexResamplerState st, spx_uint32_t channel_index, const spx_int16_t in, spx_uint32_t in_len, spx_int16_t out, spx_uint32_t *out_len)

EXPORT int	speex_resampler_process_interleaved_float (SpeexResamplerState st, const float in, spx_uint32_t in_len, float out, spx_uint32_t *out_len)

EXPORT int	speex_resampler_process_interleaved_int (SpeexResamplerState st, const spx_int16_t in, spx_uint32_t in_len, spx_int16_t out, spx_uint32_t *out_len)

static int	speex_resampler_process_native (SpeexResamplerState st, spx_uint32_t channel_index, spx_uint32_t in_len, spx_word16_t out, spx_uint32_t out_len)

EXPORT int	speex_resampler_reset_mem (SpeexResamplerState *st)

EXPORT void	speex_resampler_set_input_stride (SpeexResamplerState *st, spx_uint32_t stride)

EXPORT void	speex_resampler_set_output_stride (SpeexResamplerState *st, spx_uint32_t stride)

EXPORT int	speex_resampler_set_quality (SpeexResamplerState *st, int quality)

EXPORT int	speex_resampler_set_rate (SpeexResamplerState *st, spx_uint32_t in_rate, spx_uint32_t out_rate)

EXPORT int	speex_resampler_set_rate_frac (SpeexResamplerState *st, spx_uint32_t ratio_num, spx_uint32_t ratio_den, spx_uint32_t in_rate, spx_uint32_t out_rate)

EXPORT int	speex_resampler_skip_zeros (SpeexResamplerState *st)

EXPORT const char *	speex_resampler_strerror (int err)

static int	update_filter (SpeexResamplerState *st)

Variables
static const struct FuncDef	_KAISER10 = {kaiser10_table, 32}

static const struct FuncDef	_KAISER12 = {kaiser12_table, 64}

static const struct FuncDef	_KAISER6 = {kaiser6_table, 32}

static const struct FuncDef	_KAISER8 = {kaiser8_table, 32}

static const double	kaiser10_table [36]

static const double	kaiser12_table [68]

static const double	kaiser6_table [36]

static const double	kaiser8_table [36]

static const struct QualityMapping	quality_map [11]

Macro Definition Documentation

◆ FIXED_STACK_ALLOC

#define FIXED_STACK_ALLOC 1024

Definition at line 111 of file resample.c.

◆ IMAX

#define IMAX	(	a,
		b
	)	((a) > (b) ? (a) : (b))

Definition at line 92 of file resample.c.

◆ IMIN

#define IMIN	(	a,
		b
	)	((a) < (b) ? (a) : (b))

Definition at line 93 of file resample.c.

◆ KAISER10

#define KAISER10 (&_KAISER10)

Definition at line 204 of file resample.c.

◆ KAISER12

#define KAISER12 (&_KAISER12)

Definition at line 200 of file resample.c.

◆ KAISER6

#define KAISER6 (&_KAISER6)

Definition at line 208 of file resample.c.

◆ KAISER8

#define KAISER8 (&_KAISER8)

Definition at line 206 of file resample.c.

◆ M_PI

#define M_PI 3.14159265358979323846

Definition at line 83 of file resample.c.

◆ NULL

#define NULL 0

Examples: app_skel.c.

Definition at line 96 of file resample.c.

◆ WORD2INT

#define WORD2INT ( x ) ((x) < -32767 ? -32768 : ((x) > 32766 ? 32767 : (x)))

Definition at line 87 of file resample.c.

Typedef Documentation

◆ resampler_basic_func

typedef int(* resampler_basic_func) (SpeexResamplerState *, spx_uint32_t, const spx_word16_t *, spx_uint32_t *, spx_word16_t *, spx_uint32_t *)

Definition at line 114 of file resample.c.

Function Documentation

◆ compute_func()

static double compute_func	(	float	x,
		const struct FuncDef *	func
	)

static

Definition at line 242 of file resample.c.

{
   float y, frac;
   double interp[4];
   int ind;
   y = x*func->oversample;
   ind = (int)floor(y);
   frac = (y-ind);
   /* CSE with handle the repeated powers */
   interp[3] =  -0.1666666667*frac + 0.1666666667*(frac*frac*frac);
   interp[2] = frac + 0.5*(frac*frac) - 0.5*(frac*frac*frac);
   /*interp[2] = 1.f - 0.5f*frac - frac*frac + 0.5f*frac*frac*frac;*/
   interp[0] = -0.3333333333*frac + 0.5*(frac*frac) - 0.1666666667*(frac*frac*frac);
   /* Just to make sure we don't have rounding problems */
   interp[1] = 1.f-interp[3]-interp[2]-interp[0];
 
   /*sum = frac*accum[1] + (1-frac)*accum[2];*/
   return interp[0]*func->table[ind] + interp[1]*func->table[ind+1] + interp[2]*func->table[ind+2] + interp[3]*func->table[ind+3];
}

References FuncDef::oversample, and FuncDef::table.

Referenced by sinc().

◆ cubic_coef()

static void cubic_coef	(	spx_word16_t	x,
		spx_word16_t	interp[4]
	)

static

Definition at line 304 of file resample.c.

{
   /* Compute interpolation coefficients. I'm not sure whether this corresponds to cubic interpolation
   but I know it's MMSE-optimal on a sinc */
   spx_word16_t x2, x3;
   x2 = MULT16_16_P15(x, x);
   x3 = MULT16_16_P15(x, x2);
   interp[0] = PSHR32(MULT16_16(QCONST16(-0.16667f, 15),x) + MULT16_16(QCONST16(0.16667f, 15),x3),15);
   interp[1] = EXTRACT16(EXTEND32(x) + SHR32(SUB32(EXTEND32(x2),EXTEND32(x3)),1));
   interp[3] = PSHR32(MULT16_16(QCONST16(-0.33333f, 15),x) + MULT16_16(QCONST16(.5f,15),x2) - MULT16_16(QCONST16(0.16667f, 15),x3),15);
   /* Just to make sure we don't have rounding problems */
   interp[2] = Q15_ONE-interp[0]-interp[1]-interp[3];
   if (interp[2]<32767)
      interp[2]+=1;
}

References EXTEND32, EXTRACT16, MULT16_16, MULT16_16_P15, PSHR32, Q15_ONE, QCONST16, SHR32, and SUB32.

Referenced by resampler_basic_interpolate_single().

◆ resampler_basic_direct_single()

static int resampler_basic_direct_single	(	SpeexResamplerState *	st,
		spx_uint32_t	channel_index,
		const spx_word16_t *	in,
		spx_uint32_t *	in_len,
		spx_word16_t *	out,
		spx_uint32_t *	out_len
	)

static

Definition at line 333 of file resample.c.

{
   const int N = st->filt_len;
   int out_sample = 0;
   int last_sample = st->last_sample[channel_index];
   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
   const spx_word16_t *sinc_table = st->sinc_table;
   const int out_stride = st->out_stride;
   const int int_advance = st->int_advance;
   const int frac_advance = st->frac_advance;
   const spx_uint32_t den_rate = st->den_rate;
   spx_word32_t sum;
 
   while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
   {
      const spx_word16_t *sinct = & sinc_table[samp_frac_num*N];
      const spx_word16_t *iptr = & in[last_sample];
 
#ifndef OVERRIDE_INNER_PRODUCT_SINGLE
      int j;
      sum = 0;
      for(j=0;j<N;j++) sum += MULT16_16(sinct[j], iptr[j]);
 
/*    This code is slower on most DSPs which have only 2 accumulators.
      Plus this this forces truncation to 32 bits and you lose the HW guard bits.
      I think we can trust the compiler and let it vectorize and/or unroll itself.
      spx_word32_t accum[4] = {0,0,0,0};
      for(j=0;j<N;j+=4) {
        accum[0] += MULT16_16(sinct[j], iptr[j]);
        accum[1] += MULT16_16(sinct[j+1], iptr[j+1]);
        accum[2] += MULT16_16(sinct[j+2], iptr[j+2]);
        accum[3] += MULT16_16(sinct[j+3], iptr[j+3]);
      }
      sum = accum[0] + accum[1] + accum[2] + accum[3];
*/
      sum = SATURATE32PSHR(sum, 15, 32767);
#else
      sum = inner_product_single(sinct, iptr, N);
#endif
 
      out[out_stride * out_sample++] = sum;
      last_sample += int_advance;
      samp_frac_num += frac_advance;
      if (samp_frac_num >= den_rate)
      {
         samp_frac_num -= den_rate;
         last_sample++;
      }
   }
 
   st->last_sample[channel_index] = last_sample;
   st->samp_frac_num[channel_index] = samp_frac_num;
   return out_sample;
}

References SpeexResamplerState_::den_rate, SpeexResamplerState_::filt_len, SpeexResamplerState_::frac_advance, in, inner_product_single(), SpeexResamplerState_::int_advance, SpeexResamplerState_::last_sample, MULT16_16, out, SpeexResamplerState_::out_stride, SpeexResamplerState_::samp_frac_num, SATURATE32PSHR, and SpeexResamplerState_::sinc_table.

Referenced by update_filter().

◆ resampler_basic_interpolate_single()

static int resampler_basic_interpolate_single	(	SpeexResamplerState *	st,
		spx_uint32_t	channel_index,
		const spx_word16_t *	in,
		spx_uint32_t *	in_len,
		spx_word16_t *	out,
		spx_uint32_t *	out_len
	)

static

Definition at line 440 of file resample.c.

{
   const int N = st->filt_len;
   int out_sample = 0;
   int last_sample = st->last_sample[channel_index];
   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
   const int out_stride = st->out_stride;
   const int int_advance = st->int_advance;
   const int frac_advance = st->frac_advance;
   const spx_uint32_t den_rate = st->den_rate;
   spx_word32_t sum;
 
   while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
   {
      const spx_word16_t *iptr = & in[last_sample];
 
      const int offset = samp_frac_num*st->oversample/st->den_rate;
#ifdef FIXED_POINT
      const spx_word16_t frac = PDIV32(SHL32((samp_frac_num*st->oversample) % st->den_rate,15),st->den_rate);
#else
      const spx_word16_t frac = ((float)((samp_frac_num*st->oversample) % st->den_rate))/st->den_rate;
#endif
      spx_word16_t interp[4];
 
 
#ifndef OVERRIDE_INTERPOLATE_PRODUCT_SINGLE
      int j;
      spx_word32_t accum[4] = {0,0,0,0};
 
      for(j=0;j<N;j++) {
        const spx_word16_t curr_in=iptr[j];
        accum[0] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset-2]);
        accum[1] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset-1]);
        accum[2] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset]);
        accum[3] += MULT16_16(curr_in,st->sinc_table[4+(j+1)*st->oversample-offset+1]);
      }
 
      cubic_coef(frac, interp);
      sum = MULT16_32_Q15(interp[0],SHR32(accum[0], 1)) + MULT16_32_Q15(interp[1],SHR32(accum[1], 1)) + MULT16_32_Q15(interp[2],SHR32(accum[2], 1)) + MULT16_32_Q15(interp[3],SHR32(accum[3], 1));
      sum = SATURATE32PSHR(sum, 15, 32767);
#else
      cubic_coef(frac, interp);
      sum = interpolate_product_single(iptr, st->sinc_table + st->oversample + 4 - offset - 2, N, st->oversample, interp);
#endif
 
      out[out_stride * out_sample++] = sum;
      last_sample += int_advance;
      samp_frac_num += frac_advance;
      if (samp_frac_num >= den_rate)
      {
         samp_frac_num -= den_rate;
         last_sample++;
      }
   }
 
   st->last_sample[channel_index] = last_sample;
   st->samp_frac_num[channel_index] = samp_frac_num;
   return out_sample;
}

References cubic_coef(), SpeexResamplerState_::den_rate, SpeexResamplerState_::filt_len, SpeexResamplerState_::frac_advance, in, SpeexResamplerState_::int_advance, interpolate_product_single(), SpeexResamplerState_::last_sample, MULT16_16, MULT16_32_Q15, out, SpeexResamplerState_::out_stride, SpeexResamplerState_::oversample, PDIV32, SpeexResamplerState_::samp_frac_num, SATURATE32PSHR, SHL32, SHR32, and SpeexResamplerState_::sinc_table.

Referenced by update_filter().

◆ resampler_basic_zero()

static int resampler_basic_zero	(	SpeexResamplerState *	st,
		spx_uint32_t	channel_index,
		const spx_word16_t *	in,
		spx_uint32_t *	in_len,
		spx_word16_t *	out,
		spx_uint32_t *	out_len
	)

static

Definition at line 567 of file resample.c.

{
   int out_sample = 0;
   int last_sample = st->last_sample[channel_index];
   spx_uint32_t samp_frac_num = st->samp_frac_num[channel_index];
   const int out_stride = st->out_stride;
   const int int_advance = st->int_advance;
   const int frac_advance = st->frac_advance;
   const spx_uint32_t den_rate = st->den_rate;
 
   while (!(last_sample >= (spx_int32_t)*in_len || out_sample >= (spx_int32_t)*out_len))
   {
      out[out_stride * out_sample++] = 0;
      last_sample += int_advance;
      samp_frac_num += frac_advance;
      if (samp_frac_num >= den_rate)
      {
         samp_frac_num -= den_rate;
         last_sample++;
      }
   }
 
   st->last_sample[channel_index] = last_sample;
   st->samp_frac_num[channel_index] = samp_frac_num;
   return out_sample;
}

References SpeexResamplerState_::den_rate, SpeexResamplerState_::frac_advance, SpeexResamplerState_::int_advance, SpeexResamplerState_::last_sample, out, SpeexResamplerState_::out_stride, and SpeexResamplerState_::samp_frac_num.

Referenced by speex_resampler_process_float(), speex_resampler_process_int(), speex_resampler_process_interleaved_float(), speex_resampler_process_interleaved_int(), and update_filter().

◆ sinc()

static spx_word16_t sinc	(	float	cutoff,
		float	x,
		int	N,
		const struct FuncDef *	window_func
	)

static

Definition at line 277 of file resample.c.

{
   /*fprintf (stderr, "%f ", x);*/
   float xx = x * cutoff;
   if (fabs(x)<1e-6f)
      return WORD2INT(32768.*cutoff);
   else if (fabs(x) > .5f*N)
      return 0;
   /*FIXME: Can it really be any slower than this? */
   return WORD2INT(32768.*cutoff*sin(M_PI*xx)/(M_PI*xx) * compute_func(fabs(2.*x/N), window_func));
}

References compute_func(), M_PI, QualityMapping::window_func, and WORD2INT.

Referenced by update_filter().

◆ speex_resampler_destroy()

EXPORT void speex_resampler_destroy ( SpeexResamplerState * st )

Destroy a resampler state.

Parameters

st	Resampler state

Definition at line 849 of file resample.c.

{
   speex_free(st->mem);
   speex_free(st->sinc_table);
   speex_free(st->last_sample);
   speex_free(st->magic_samples);
   speex_free(st->samp_frac_num);
   speex_free(st);
}

References SpeexResamplerState_::last_sample, SpeexResamplerState_::magic_samples, SpeexResamplerState_::mem, SpeexResamplerState_::samp_frac_num, and SpeexResamplerState_::sinc_table.

Referenced by resamp_destroy(), and speex_resampler_init_frac().

◆ speex_resampler_get_input_latency()

EXPORT int speex_resampler_get_input_latency ( SpeexResamplerState * st )

Get the latency in input samples introduced by the resampler.

Parameters

st	Resampler state

Definition at line 1159 of file resample.c.

{
  return st->filt_len / 2;
}

References SpeexResamplerState_::filt_len.

◆ speex_resampler_get_input_stride()

EXPORT void speex_resampler_get_input_stride	(	SpeexResamplerState *	st,
		spx_uint32_t *	stride
	)

Get the input stride.

Parameters

st	Resampler state
stride	Input stride copied

Definition at line 1144 of file resample.c.

{
   *stride = st->in_stride;
}

References SpeexResamplerState_::in_stride.

◆ speex_resampler_get_output_latency()

EXPORT int speex_resampler_get_output_latency ( SpeexResamplerState * st )

Get the latency in output samples introduced by the resampler.

Parameters

st	Resampler state

Definition at line 1164 of file resample.c.

{
  return ((st->filt_len / 2) * st->den_rate + (st->num_rate >> 1)) / st->num_rate;
}

References SpeexResamplerState_::den_rate, SpeexResamplerState_::filt_len, and SpeexResamplerState_::num_rate.

◆ speex_resampler_get_output_stride()

EXPORT void speex_resampler_get_output_stride	(	SpeexResamplerState *	st,
		spx_uint32_t *	stride
	)

Get the output stride.

Parameters

st	Resampler state copied
stride	Output stride

Definition at line 1154 of file resample.c.

{
   *stride = st->out_stride;
}

References SpeexResamplerState_::out_stride.

◆ speex_resampler_get_quality()

EXPORT void speex_resampler_get_quality	(	SpeexResamplerState *	st,
		int *	quality
	)

Get the conversion quality.

Parameters

st	Resampler state
quality	Resampling quality between 0 and 10, where 0 has poor quality and 10 has very high quality.

Definition at line 1134 of file resample.c.

{
   *quality = st->quality;
}

References quality, and SpeexResamplerState_::quality.

◆ speex_resampler_get_rate()

EXPORT void speex_resampler_get_rate	(	SpeexResamplerState *	st,
		spx_uint32_t *	in_rate,
		spx_uint32_t *	out_rate
	)

Get the current input/output sampling rates (integer value).

Parameters

st	Resampler state
in_rate	Input sampling rate (integer number of Hz) copied.
out_rate	Output sampling rate (integer number of Hz) copied.

Definition at line 1071 of file resample.c.

{
   *in_rate = st->in_rate;
   *out_rate = st->out_rate;
}

References SpeexResamplerState_::in_rate, and SpeexResamplerState_::out_rate.

◆ speex_resampler_get_ratio()

EXPORT void speex_resampler_get_ratio	(	SpeexResamplerState *	st,
		spx_uint32_t *	ratio_num,
		spx_uint32_t *	ratio_den
	)

Get the current resampling ratio. This will be reduced to the least common denominator.

Parameters

st	Resampler state
ratio_num	Numerator of the sampling rate ratio copied
ratio_den	Denominator of the sampling rate ratio copied

Definition at line 1116 of file resample.c.

{
   *ratio_num = st->num_rate;
   *ratio_den = st->den_rate;
}

References SpeexResamplerState_::den_rate, and SpeexResamplerState_::num_rate.

◆ speex_resampler_init()

EXPORT SpeexResamplerState * speex_resampler_init	(	spx_uint32_t	nb_channels,
		spx_uint32_t	in_rate,
		spx_uint32_t	out_rate,
		int	quality,
		int *	err
	)

Create a new resampler with integer input and output rates.

Parameters

nb_channels	Number of channels to be processed
in_rate	Input sampling rate (integer number of Hz).
out_rate	Output sampling rate (integer number of Hz).
quality	Resampling quality between 0 and 10, where 0 has poor quality and 10 has very high quality.
err

Returns: Newly created resampler state

Return values

NULL	Error: not enough memory

Definition at line 783 of file resample.c.

{
   return speex_resampler_init_frac(nb_channels, in_rate, out_rate, in_rate, out_rate, quality, err);
}

References quality, and speex_resampler_init_frac().

Referenced by resamp_new().

◆ speex_resampler_init_frac()

EXPORT SpeexResamplerState * speex_resampler_init_frac	(	spx_uint32_t	nb_channels,
		spx_uint32_t	ratio_num,
		spx_uint32_t	ratio_den,
		spx_uint32_t	in_rate,
		spx_uint32_t	out_rate,
		int	quality,
		int *	err
	)

Create a new resampler with fractional input/output rates. The sampling rate ratio is an arbitrary rational number with both the numerator and denominator being 32-bit integers.

Parameters

nb_channels	Number of channels to be processed
ratio_num	Numerator of the sampling rate ratio
ratio_den	Denominator of the sampling rate ratio
in_rate	Input sampling rate rounded to the nearest integer (in Hz).
out_rate	Output sampling rate rounded to the nearest integer (in Hz).
quality	Resampling quality between 0 and 10, where 0 has poor quality and 10 has very high quality.
err

Returns: Newly created resampler state

Return values

NULL	Error: not enough memory

Definition at line 788 of file resample.c.

{
   spx_uint32_t i;
   SpeexResamplerState *st;
   int filter_err;
 
   if (quality > 10 || quality < 0)
   {
      if (err)
         *err = RESAMPLER_ERR_INVALID_ARG;
      return NULL;
   }
   st = (SpeexResamplerState *)speex_alloc(sizeof(SpeexResamplerState));
   st->initialised = 0;
   st->started = 0;
   st->in_rate = 0;
   st->out_rate = 0;
   st->num_rate = 0;
   st->den_rate = 0;
   st->quality = -1;
   st->sinc_table_length = 0;
   st->mem_alloc_size = 0;
   st->filt_len = 0;
   st->mem = 0;
   st->resampler_ptr = 0;
 
   st->cutoff = 1.f;
   st->nb_channels = nb_channels;
   st->in_stride = 1;
   st->out_stride = 1;
 
   st->buffer_size = 160;
 
   /* Per channel data */
   st->last_sample = (spx_int32_t*)speex_alloc(nb_channels*sizeof(spx_int32_t));
   st->magic_samples = (spx_uint32_t*)speex_alloc(nb_channels*sizeof(spx_uint32_t));
   st->samp_frac_num = (spx_uint32_t*)speex_alloc(nb_channels*sizeof(spx_uint32_t));
   for (i=0;i<nb_channels;i++)
   {
      st->last_sample[i] = 0;
      st->magic_samples[i] = 0;
      st->samp_frac_num[i] = 0;
   }
 
   speex_resampler_set_quality(st, quality);
   speex_resampler_set_rate_frac(st, ratio_num, ratio_den, in_rate, out_rate);
 
   filter_err = update_filter(st);
   if (filter_err == RESAMPLER_ERR_SUCCESS)
   {
      st->initialised = 1;
   } else {
      speex_resampler_destroy(st);
      st = NULL;
   }
   if (err)
      *err = filter_err;
 
   return st;
}

Referenced by speex_resampler_init().

◆ speex_resampler_magic()

static int speex_resampler_magic	(	SpeexResamplerState *	st,
		spx_uint32_t	channel_index,
		spx_word16_t **	out,
		spx_uint32_t	out_len
	)

static

Definition at line 885 of file resample.c.

                                                                                                                                {
   spx_uint32_t tmp_in_len = st->magic_samples[channel_index];
   spx_word16_t *mem = st->mem + channel_index * st->mem_alloc_size;
   const int N = st->filt_len;
 
   speex_resampler_process_native(st, channel_index, &tmp_in_len, *out, &out_len);
 
   st->magic_samples[channel_index] -= tmp_in_len;
 
   /* If we couldn't process all "magic" input samples, save the rest for next time */
   if (st->magic_samples[channel_index])
   {
      spx_uint32_t i;
      for (i=0;i<st->magic_samples[channel_index];i++)
         mem[N-1+i]=mem[N-1+i+tmp_in_len];
   }
   *out += out_len*st->out_stride;
   return out_len;
}

References SpeexResamplerState_::filt_len, SpeexResamplerState_::magic_samples, SpeexResamplerState_::mem, SpeexResamplerState_::mem_alloc_size, out, SpeexResamplerState_::out_stride, and speex_resampler_process_native().

Referenced by speex_resampler_process_float(), and speex_resampler_process_int().

◆ speex_resampler_process_float()

EXPORT int speex_resampler_process_float	(	SpeexResamplerState *	st,
		spx_uint32_t	channel_index,
		const float *	in,
		spx_uint32_t *	in_len,
		float *	out,
		spx_uint32_t *	out_len
	)

Resample a float array. The input and output buffers must not overlap.

Parameters

st	Resampler state
channel_index	Index of the channel to process for the multi-channel base (0 otherwise)
in	Input buffer
in_len	Number of input samples in the input buffer. Returns the number of samples processed
out	Output buffer
out_len	Size of the output buffer. Returns the number of samples written

Definition at line 947 of file resample.c.

{
   int j;
   const int istride_save = st->in_stride;
   const int ostride_save = st->out_stride;
   spx_uint32_t ilen = *in_len;
   spx_uint32_t olen = *out_len;
   spx_word16_t *x = st->mem + channel_index * st->mem_alloc_size;
   const spx_uint32_t xlen = st->mem_alloc_size - (st->filt_len - 1);
#ifdef VAR_ARRAYS
   const unsigned int ylen = (olen < FIXED_STACK_ALLOC) ? olen : FIXED_STACK_ALLOC;
   VARDECL(spx_word16_t *ystack);
   ALLOC(ystack, ylen, spx_word16_t);
#else
   const unsigned int ylen = FIXED_STACK_ALLOC;
   spx_word16_t ystack[FIXED_STACK_ALLOC];
#endif
 
   st->out_stride = 1;
 
   while (ilen && olen) {
     spx_word16_t *y = ystack;
     spx_uint32_t ichunk = (ilen > xlen) ? xlen : ilen;
     spx_uint32_t ochunk = (olen > ylen) ? ylen : olen;
     spx_uint32_t omagic = 0;
 
     if (st->magic_samples[channel_index]) {
       omagic = speex_resampler_magic(st, channel_index, &y, ochunk);
       ochunk -= omagic;
       olen -= omagic;
     }
     if (! st->magic_samples[channel_index]) {
       if (in) {
         for(j=0;j<ichunk;++j)
#ifdef FIXED_POINT
           x[j+st->filt_len-1]=WORD2INT(in[j*istride_save]);
#else
           x[j+st->filt_len-1]=in[j*istride_save];
#endif
       } else {
         for(j=0;j<ichunk;++j)
           x[j+st->filt_len-1]=0;
       }
 
       speex_resampler_process_native(st, channel_index, &ichunk, y, &ochunk);
     } else {
       ichunk = 0;
       ochunk = 0;
     }
 
     for (j=0;j<ochunk+omagic;++j)
#ifdef FIXED_POINT
        out[j*ostride_save] = ystack[j];
#else
        out[j*ostride_save] = WORD2INT(ystack[j]);
#endif
 
     ilen -= ichunk;
     olen -= ochunk;
     out += (ochunk+omagic) * ostride_save;
     if (in)
       in += ichunk * istride_save;
   }
   st->out_stride = ostride_save;
   *in_len -= ilen;
   *out_len -= olen;
 
   return st->resampler_ptr == resampler_basic_zero ? RESAMPLER_ERR_ALLOC_FAILED : RESAMPLER_ERR_SUCCESS;
}

References ALLOC, SpeexResamplerState_::filt_len, FIXED_POINT, FIXED_STACK_ALLOC, in, SpeexResamplerState_::in_stride, SpeexResamplerState_::magic_samples, SpeexResamplerState_::mem, SpeexResamplerState_::mem_alloc_size, out, SpeexResamplerState_::out_stride, resampler_basic_zero(), RESAMPLER_ERR_ALLOC_FAILED, RESAMPLER_ERR_SUCCESS, SpeexResamplerState_::resampler_ptr, speex_resampler_magic(), speex_resampler_process_native(), VARDECL, and WORD2INT.

Referenced by speex_resampler_process_interleaved_float().

◆ speex_resampler_process_int()

EXPORT int speex_resampler_process_int	(	SpeexResamplerState *	st,
		spx_uint32_t	channel_index,
		const spx_int16_t *	in,
		spx_uint32_t *	in_len,
		spx_int16_t *	out,
		spx_uint32_t *	out_len
	)

Resample an int array. The input and output buffers must not overlap.

Parameters

st	Resampler state
channel_index	Index of the channel to process for the multi-channel base (0 otherwise)
in	Input buffer
in_len	Number of input samples in the input buffer. Returns the number of samples processed
out	Output buffer
out_len	Size of the output buffer. Returns the number of samples written

Definition at line 906 of file resample.c.

{
   int j;
   spx_uint32_t ilen = *in_len;
   spx_uint32_t olen = *out_len;
   spx_word16_t *x = st->mem + channel_index * st->mem_alloc_size;
   const int filt_offs = st->filt_len - 1;
   const spx_uint32_t xlen = st->mem_alloc_size - filt_offs;
   const int istride = st->in_stride;
 
   if (st->magic_samples[channel_index])
      olen -= speex_resampler_magic(st, channel_index, &out, olen);
   if (! st->magic_samples[channel_index]) {
      while (ilen && olen) {
        spx_uint32_t ichunk = (ilen > xlen) ? xlen : ilen;
        spx_uint32_t ochunk = olen;
 
        if (in) {
           for(j=0;j<ichunk;++j)
              x[j+filt_offs]=in[j*istride];
        } else {
          for(j=0;j<ichunk;++j)
            x[j+filt_offs]=0;
        }
        speex_resampler_process_native(st, channel_index, &ichunk, out, &ochunk);
        ilen -= ichunk;
        olen -= ochunk;
        out += ochunk * st->out_stride;
        if (in)
           in += ichunk * istride;
      }
   }
   *in_len -= ilen;
   *out_len -= olen;
   return st->resampler_ptr == resampler_basic_zero ? RESAMPLER_ERR_ALLOC_FAILED : RESAMPLER_ERR_SUCCESS;
}

References SpeexResamplerState_::filt_len, in, SpeexResamplerState_::in_stride, SpeexResamplerState_::magic_samples, SpeexResamplerState_::mem, SpeexResamplerState_::mem_alloc_size, out, SpeexResamplerState_::out_stride, resampler_basic_zero(), RESAMPLER_ERR_ALLOC_FAILED, RESAMPLER_ERR_SUCCESS, SpeexResamplerState_::resampler_ptr, speex_resampler_magic(), and speex_resampler_process_native().

Referenced by resamp_framein(), and speex_resampler_process_interleaved_int().

◆ speex_resampler_process_interleaved_float()

EXPORT int speex_resampler_process_interleaved_float	(	SpeexResamplerState *	st,
		const float *	in,
		spx_uint32_t *	in_len,
		float *	out,
		spx_uint32_t *	out_len
	)

Resample an interleaved float array. The input and output buffers must not overlap.

Parameters

st	Resampler state
in	Input buffer
in_len	Number of input samples in the input buffer. Returns the number of samples processed. This is all per-channel.
out	Output buffer
out_len	Size of the output buffer. Returns the number of samples written. This is all per-channel.

Definition at line 1020 of file resample.c.

{
   spx_uint32_t i;
   int istride_save, ostride_save;
   spx_uint32_t bak_out_len = *out_len;
   spx_uint32_t bak_in_len = *in_len;
   istride_save = st->in_stride;
   ostride_save = st->out_stride;
   st->in_stride = st->out_stride = st->nb_channels;
   for (i=0;i<st->nb_channels;i++)
   {
      *out_len = bak_out_len;
      *in_len = bak_in_len;
      if (in != NULL)
         speex_resampler_process_float(st, i, in+i, in_len, out+i, out_len);
      else
         speex_resampler_process_float(st, i, NULL, in_len, out+i, out_len);
   }
   st->in_stride = istride_save;
   st->out_stride = ostride_save;
   return st->resampler_ptr == resampler_basic_zero ? RESAMPLER_ERR_ALLOC_FAILED : RESAMPLER_ERR_SUCCESS;
}

References in, SpeexResamplerState_::in_stride, SpeexResamplerState_::nb_channels, NULL, out, SpeexResamplerState_::out_stride, resampler_basic_zero(), RESAMPLER_ERR_ALLOC_FAILED, RESAMPLER_ERR_SUCCESS, SpeexResamplerState_::resampler_ptr, and speex_resampler_process_float().

◆ speex_resampler_process_interleaved_int()

EXPORT int speex_resampler_process_interleaved_int	(	SpeexResamplerState *	st,
		const spx_int16_t *	in,
		spx_uint32_t *	in_len,
		spx_int16_t *	out,
		spx_uint32_t *	out_len
	)

Resample an interleaved int array. The input and output buffers must not overlap.

Parameters

st	Resampler state
in	Input buffer
in_len	Number of input samples in the input buffer. Returns the number of samples processed. This is all per-channel.
out	Output buffer
out_len	Size of the output buffer. Returns the number of samples written. This is all per-channel.

Definition at line 1043 of file resample.c.

{
   spx_uint32_t i;
   int istride_save, ostride_save;
   spx_uint32_t bak_out_len = *out_len;
   spx_uint32_t bak_in_len = *in_len;
   istride_save = st->in_stride;
   ostride_save = st->out_stride;
   st->in_stride = st->out_stride = st->nb_channels;
   for (i=0;i<st->nb_channels;i++)
   {
      *out_len = bak_out_len;
      *in_len = bak_in_len;
      if (in != NULL)
         speex_resampler_process_int(st, i, in+i, in_len, out+i, out_len);
      else
         speex_resampler_process_int(st, i, NULL, in_len, out+i, out_len);
   }
   st->in_stride = istride_save;
   st->out_stride = ostride_save;
   return st->resampler_ptr == resampler_basic_zero ? RESAMPLER_ERR_ALLOC_FAILED : RESAMPLER_ERR_SUCCESS;
}

References in, SpeexResamplerState_::in_stride, SpeexResamplerState_::nb_channels, NULL, out, SpeexResamplerState_::out_stride, resampler_basic_zero(), RESAMPLER_ERR_ALLOC_FAILED, RESAMPLER_ERR_SUCCESS, SpeexResamplerState_::resampler_ptr, and speex_resampler_process_int().

◆ speex_resampler_process_native()

static int speex_resampler_process_native	(	SpeexResamplerState *	st,
		spx_uint32_t	channel_index,
		spx_uint32_t *	in_len,
		spx_word16_t *	out,
		spx_uint32_t *	out_len
	)

static

Definition at line 859 of file resample.c.

{
   int j=0;
   const int N = st->filt_len;
   int out_sample = 0;
   spx_word16_t *mem = st->mem + channel_index * st->mem_alloc_size;
   spx_uint32_t ilen;
 
   st->started = 1;
 
   /* Call the right resampler through the function ptr */
   out_sample = st->resampler_ptr(st, channel_index, mem, in_len, out, out_len);
 
   if (st->last_sample[channel_index] < (spx_int32_t)*in_len)
      *in_len = st->last_sample[channel_index];
   *out_len = out_sample;
   st->last_sample[channel_index] -= *in_len;
 
   ilen = *in_len;
 
   for(j=0;j<N-1;++j)
     mem[j] = mem[j+ilen];
 
   return RESAMPLER_ERR_SUCCESS;
}

References SpeexResamplerState_::filt_len, SpeexResamplerState_::last_sample, SpeexResamplerState_::mem, SpeexResamplerState_::mem_alloc_size, out, RESAMPLER_ERR_SUCCESS, SpeexResamplerState_::resampler_ptr, and SpeexResamplerState_::started.

Referenced by speex_resampler_magic(), speex_resampler_process_float(), and speex_resampler_process_int().

◆ speex_resampler_reset_mem()

EXPORT int speex_resampler_reset_mem ( SpeexResamplerState * st )

Reset a resampler so a new (unrelated) stream can be processed.

Parameters

st	Resampler state

Definition at line 1177 of file resample.c.

{
   spx_uint32_t i;
   for (i=0;i<st->nb_channels;i++)
   {
      st->last_sample[i] = 0;
      st->magic_samples[i] = 0;
      st->samp_frac_num[i] = 0;
   }
   for (i=0;i<st->nb_channels*(st->filt_len-1);i++)
      st->mem[i] = 0;
   return RESAMPLER_ERR_SUCCESS;
}

References SpeexResamplerState_::filt_len, SpeexResamplerState_::last_sample, SpeexResamplerState_::magic_samples, SpeexResamplerState_::mem, SpeexResamplerState_::nb_channels, RESAMPLER_ERR_SUCCESS, and SpeexResamplerState_::samp_frac_num.

◆ speex_resampler_set_input_stride()

EXPORT void speex_resampler_set_input_stride	(	SpeexResamplerState *	st,
		spx_uint32_t	stride
	)

Set (change) the input stride.

Parameters

st	Resampler state
stride	Input stride

Definition at line 1139 of file resample.c.

{
   st->in_stride = stride;
}

References SpeexResamplerState_::in_stride.

◆ speex_resampler_set_output_stride()

EXPORT void speex_resampler_set_output_stride	(	SpeexResamplerState *	st,
		spx_uint32_t	stride
	)

Set (change) the output stride.

Parameters

st	Resampler state
stride	Output stride

Definition at line 1149 of file resample.c.

{
   st->out_stride = stride;
}

References SpeexResamplerState_::out_stride.

◆ speex_resampler_set_quality()

EXPORT int speex_resampler_set_quality	(	SpeexResamplerState *	st,
		int	quality
	)

Set (change) the conversion quality.

Parameters

st	Resampler state
quality	Resampling quality between 0 and 10, where 0 has poor quality and 10 has very high quality.

Definition at line 1122 of file resample.c.

{
   if (quality > 10 || quality < 0)
      return RESAMPLER_ERR_INVALID_ARG;
   if (st->quality == quality)
      return RESAMPLER_ERR_SUCCESS;
   st->quality = quality;
   if (st->initialised)
      return update_filter(st);
   return RESAMPLER_ERR_SUCCESS;
}

References SpeexResamplerState_::initialised, quality, SpeexResamplerState_::quality, RESAMPLER_ERR_INVALID_ARG, RESAMPLER_ERR_SUCCESS, and update_filter().

Referenced by speex_resampler_init_frac().

◆ speex_resampler_set_rate()

EXPORT int speex_resampler_set_rate	(	SpeexResamplerState *	st,
		spx_uint32_t	in_rate,
		spx_uint32_t	out_rate
	)

Set (change) the input/output sampling rates (integer value).

Parameters

st	Resampler state
in_rate	Input sampling rate (integer number of Hz).
out_rate	Output sampling rate (integer number of Hz).

Definition at line 1066 of file resample.c.

{
   return speex_resampler_set_rate_frac(st, in_rate, out_rate, in_rate, out_rate);
}

References speex_resampler_set_rate_frac().

◆ speex_resampler_set_rate_frac()

EXPORT int speex_resampler_set_rate_frac	(	SpeexResamplerState *	st,
		spx_uint32_t	ratio_num,
		spx_uint32_t	ratio_den,
		spx_uint32_t	in_rate,
		spx_uint32_t	out_rate
	)

Set (change) the input/output sampling rates and resampling ratio (fractional values in Hz supported).

Parameters

st	Resampler state
ratio_num	Numerator of the sampling rate ratio
ratio_den	Denominator of the sampling rate ratio
in_rate	Input sampling rate rounded to the nearest integer (in Hz).
out_rate	Output sampling rate rounded to the nearest integer (in Hz).

Definition at line 1077 of file resample.c.

{
   spx_uint32_t fact;
   spx_uint32_t old_den;
   spx_uint32_t i;
   if (st->in_rate == in_rate && st->out_rate == out_rate && st->num_rate == ratio_num && st->den_rate == ratio_den)
      return RESAMPLER_ERR_SUCCESS;
 
   old_den = st->den_rate;
   st->in_rate = in_rate;
   st->out_rate = out_rate;
   st->num_rate = ratio_num;
   st->den_rate = ratio_den;
   /* FIXME: This is terribly inefficient, but who cares (at least for now)? */
   for (fact=2;fact<=IMIN(st->num_rate, st->den_rate);fact++)
   {
      while ((st->num_rate % fact == 0) && (st->den_rate % fact == 0))
      {
         st->num_rate /= fact;
         st->den_rate /= fact;
      }
   }
 
   if (old_den > 0)
   {
      for (i=0;i<st->nb_channels;i++)
      {
         st->samp_frac_num[i]=st->samp_frac_num[i]*st->den_rate/old_den;
         /* Safety net */
         if (st->samp_frac_num[i] >= st->den_rate)
            st->samp_frac_num[i] = st->den_rate-1;
      }
   }
 
   if (st->initialised)
      return update_filter(st);
   return RESAMPLER_ERR_SUCCESS;
}

References SpeexResamplerState_::den_rate, IMIN, SpeexResamplerState_::in_rate, SpeexResamplerState_::initialised, SpeexResamplerState_::nb_channels, SpeexResamplerState_::num_rate, SpeexResamplerState_::out_rate, RESAMPLER_ERR_SUCCESS, SpeexResamplerState_::samp_frac_num, and update_filter().

Referenced by speex_resampler_init_frac(), and speex_resampler_set_rate().

◆ speex_resampler_skip_zeros()

EXPORT int speex_resampler_skip_zeros ( SpeexResamplerState * st )

Make sure that the first samples to go out of the resamplers don't have leading zeros. This is only useful before starting to use a newly created resampler. It is recommended to use that when resampling an audio file, as it will generate a file with the same length. For real-time processing, it is probably easier not to use this call (so that the output duration is the same for the first frame).

Parameters

st	Resampler state

Definition at line 1169 of file resample.c.

{
   spx_uint32_t i;
   for (i=0;i<st->nb_channels;i++)
      st->last_sample[i] = st->filt_len/2;
   return RESAMPLER_ERR_SUCCESS;
}

References SpeexResamplerState_::filt_len, SpeexResamplerState_::last_sample, SpeexResamplerState_::nb_channels, and RESAMPLER_ERR_SUCCESS.

◆ speex_resampler_strerror()

EXPORT const char * speex_resampler_strerror ( int err )

Returns the English meaning for an error code

Parameters

err	Error code

Returns: English string

Definition at line 1191 of file resample.c.

{
   switch (err)
   {
      case RESAMPLER_ERR_SUCCESS:
         return "Success.";
      case RESAMPLER_ERR_ALLOC_FAILED:
         return "Memory allocation failed.";
      case RESAMPLER_ERR_BAD_STATE:
         return "Bad resampler state.";
      case RESAMPLER_ERR_INVALID_ARG:
         return "Invalid argument.";
      case RESAMPLER_ERR_PTR_OVERLAP:
         return "Input and output buffers overlap.";
      default:
         return "Unknown error. Bad error code or strange version mismatch.";
   }
}

References RESAMPLER_ERR_ALLOC_FAILED, RESAMPLER_ERR_BAD_STATE, RESAMPLER_ERR_INVALID_ARG, RESAMPLER_ERR_PTR_OVERLAP, and RESAMPLER_ERR_SUCCESS.

◆ update_filter()

static int update_filter ( SpeexResamplerState * st )

static

Definition at line 594 of file resample.c.

{
   spx_uint32_t old_length = st->filt_len;
   spx_uint32_t old_alloc_size = st->mem_alloc_size;
   int use_direct;
   spx_uint32_t min_sinc_table_length;
   spx_uint32_t min_alloc_size;
 
   st->int_advance = st->num_rate/st->den_rate;
   st->frac_advance = st->num_rate%st->den_rate;
   st->oversample = quality_map[st->quality].oversample;
   st->filt_len = quality_map[st->quality].base_length;
 
   if (st->num_rate > st->den_rate)
   {
      /* down-sampling */
      st->cutoff = quality_map[st->quality].downsample_bandwidth * st->den_rate / st->num_rate;
      /* FIXME: divide the numerator and denominator by a certain amount if they're too large */
      st->filt_len = st->filt_len*st->num_rate / st->den_rate;
      /* Round up to make sure we have a multiple of 8 for SSE */
      st->filt_len = ((st->filt_len-1)&(~0x7))+8;
      if (2*st->den_rate < st->num_rate)
         st->oversample >>= 1;
      if (4*st->den_rate < st->num_rate)
         st->oversample >>= 1;
      if (8*st->den_rate < st->num_rate)
         st->oversample >>= 1;
      if (16*st->den_rate < st->num_rate)
         st->oversample >>= 1;
      if (st->oversample < 1)
         st->oversample = 1;
   } else {
      /* up-sampling */
      st->cutoff = quality_map[st->quality].upsample_bandwidth;
   }
 
   /* Choose the resampling type that requires the least amount of memory */
#ifdef RESAMPLE_FULL_SINC_TABLE
   use_direct = 1;
   if (INT_MAX/sizeof(spx_word16_t)/st->den_rate < st->filt_len)
      goto fail;
#else
   use_direct = st->filt_len*st->den_rate <= st->filt_len*st->oversample+8
                && INT_MAX/sizeof(spx_word16_t)/st->den_rate >= st->filt_len;
#endif
   if (use_direct)
   {
      min_sinc_table_length = st->filt_len*st->den_rate;
   } else {
      if ((INT_MAX/sizeof(spx_word16_t)-8)/st->oversample < st->filt_len)
         goto fail;
 
      min_sinc_table_length = st->filt_len*st->oversample+8;
   }
   if (st->sinc_table_length < min_sinc_table_length)
   {
      spx_word16_t *sinc_table = (spx_word16_t *)speex_realloc(st->sinc_table,min_sinc_table_length*sizeof(spx_word16_t));
      if (!sinc_table)
         goto fail;
 
      st->sinc_table = sinc_table;
      st->sinc_table_length = min_sinc_table_length;
   }
   if (use_direct)
   {
      spx_uint32_t i;
      for (i=0;i<st->den_rate;i++)
      {
         spx_int32_t j;
         for (j=0;j<st->filt_len;j++)
         {
            st->sinc_table[i*st->filt_len+j] = sinc(st->cutoff,((j-(spx_int32_t)st->filt_len/2+1)-((float)i)/st->den_rate), st->filt_len, quality_map[st->quality].window_func);
         }
      }
#ifdef FIXED_POINT
      st->resampler_ptr = resampler_basic_direct_single;
#else
      if (st->quality>8)
         st->resampler_ptr = resampler_basic_direct_double;
      else
         st->resampler_ptr = resampler_basic_direct_single;
#endif
      /*fprintf (stderr, "resampler uses direct sinc table and normalised cutoff %f\n", cutoff);*/
   } else {
      spx_int32_t i;
      for (i=-4;i<(spx_int32_t)(st->oversample*st->filt_len+4);i++)
         st->sinc_table[i+4] = sinc(st->cutoff,(i/(float)st->oversample - st->filt_len/2), st->filt_len, quality_map[st->quality].window_func);
#ifdef FIXED_POINT
      st->resampler_ptr = resampler_basic_interpolate_single;
#else
      if (st->quality>8)
         st->resampler_ptr = resampler_basic_interpolate_double;
      else
         st->resampler_ptr = resampler_basic_interpolate_single;
#endif
      /*fprintf (stderr, "resampler uses interpolated sinc table and normalised cutoff %f\n", cutoff);*/
   }
 
   /* Here's the place where we update the filter memory to take into account
      the change in filter length. It's probably the messiest part of the code
      due to handling of lots of corner cases. */
 
   /* Adding buffer_size to filt_len won't overflow here because filt_len
      could be multiplied by sizeof(spx_word16_t) above. */
   min_alloc_size = st->filt_len-1 + st->buffer_size;
   if (min_alloc_size > st->mem_alloc_size)
   {
      spx_word16_t *mem;
      if (INT_MAX/sizeof(spx_word16_t)/st->nb_channels < min_alloc_size)
          goto fail;
      else if (!(mem = (spx_word16_t*)speex_realloc(st->mem, st->nb_channels*min_alloc_size * sizeof(*mem))))
          goto fail;
 
      st->mem = mem;
      st->mem_alloc_size = min_alloc_size;
   }
   if (!st->started)
   {
      spx_uint32_t i;
      for (i=0;i<st->nb_channels*st->mem_alloc_size;i++)
         st->mem[i] = 0;
      /*speex_warning("reinit filter");*/
   } else if (st->filt_len > old_length)
   {
      spx_uint32_t i;
      /* Increase the filter length */
      /*speex_warning("increase filter size");*/
      for (i=st->nb_channels;i--;)
      {
         spx_uint32_t j;
         spx_uint32_t olen = old_length;
         /*if (st->magic_samples[i])*/
         {
            /* Try and remove the magic samples as if nothing had happened */
 
            /* FIXME: This is wrong but for now we need it to avoid going over the array bounds */
            olen = old_length + 2*st->magic_samples[i];
            for (j=old_length-1+st->magic_samples[i];j--;)
               st->mem[i*st->mem_alloc_size+j+st->magic_samples[i]] = st->mem[i*old_alloc_size+j];
            for (j=0;j<st->magic_samples[i];j++)
               st->mem[i*st->mem_alloc_size+j] = 0;
            st->magic_samples[i] = 0;
         }
         if (st->filt_len > olen)
         {
            /* If the new filter length is still bigger than the "augmented" length */
            /* Copy data going backward */
            for (j=0;j<olen-1;j++)
               st->mem[i*st->mem_alloc_size+(st->filt_len-2-j)] = st->mem[i*st->mem_alloc_size+(olen-2-j)];
            /* Then put zeros for lack of anything better */
            for (;j<st->filt_len-1;j++)
               st->mem[i*st->mem_alloc_size+(st->filt_len-2-j)] = 0;
            /* Adjust last_sample */
            st->last_sample[i] += (st->filt_len - olen)/2;
         } else {
            /* Put back some of the magic! */
            st->magic_samples[i] = (olen - st->filt_len)/2;
            for (j=0;j<st->filt_len-1+st->magic_samples[i];j++)
               st->mem[i*st->mem_alloc_size+j] = st->mem[i*st->mem_alloc_size+j+st->magic_samples[i]];
         }
      }
   } else if (st->filt_len < old_length)
   {
      spx_uint32_t i;
      /* Reduce filter length, this a bit tricky. We need to store some of the memory as "magic"
         samples so they can be used directly as input the next time(s) */
      for (i=0;i<st->nb_channels;i++)
      {
         spx_uint32_t j;
         spx_uint32_t old_magic = st->magic_samples[i];
         st->magic_samples[i] = (old_length - st->filt_len)/2;
         /* We must copy some of the memory that's no longer used */
         /* Copy data going backward */
         for (j=0;j<st->filt_len-1+st->magic_samples[i]+old_magic;j++)
            st->mem[i*st->mem_alloc_size+j] = st->mem[i*st->mem_alloc_size+j+st->magic_samples[i]];
         st->magic_samples[i] += old_magic;
      }
   }
   return RESAMPLER_ERR_SUCCESS;
 
fail:
   st->resampler_ptr = resampler_basic_zero;
   /* st->mem may still contain consumed input samples for the filter.
      Restore filt_len so that filt_len - 1 still points to the position after
      the last of these samples. */
   st->filt_len = old_length;
   return RESAMPLER_ERR_ALLOC_FAILED;
}

Referenced by speex_resampler_init_frac(), speex_resampler_set_quality(), and speex_resampler_set_rate_frac().

Variable Documentation

◆ _KAISER10

const struct FuncDef _KAISER10 = {kaiser10_table, 32}

static

Definition at line 203 of file resample.c.

◆ _KAISER12

const struct FuncDef _KAISER12 = {kaiser12_table, 64}

static

Definition at line 199 of file resample.c.

◆ _KAISER6

const struct FuncDef _KAISER6 = {kaiser6_table, 32}

static

Definition at line 207 of file resample.c.

◆ _KAISER8

const struct FuncDef _KAISER8 = {kaiser8_table, 32}

static

Definition at line 205 of file resample.c.

◆ kaiser10_table

const double kaiser10_table[36]

static

Definition at line 170 of file resample.c.

◆ kaiser12_table

const double kaiser12_table[68]

static

Definition at line 148 of file resample.c.

◆ kaiser6_table

const double kaiser6_table[36]

static

Definition at line 186 of file resample.c.

◆ kaiser8_table

const double kaiser8_table[36]

static

Definition at line 178 of file resample.c.

◆ quality_map

const struct QualityMapping quality_map[11]

static

Definition at line 228 of file resample.c.

Referenced by update_filter().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ FIXED_STACK_ALLOC

◆ IMAX

◆ IMIN

◆ KAISER10

◆ KAISER12

◆ KAISER6

◆ KAISER8

◆ M_PI

◆ NULL

◆ WORD2INT

Typedef Documentation

◆ resampler_basic_func

Function Documentation

◆ compute_func()

◆ cubic_coef()

◆ resampler_basic_direct_single()

◆ resampler_basic_interpolate_single()

◆ resampler_basic_zero()

◆ sinc()

◆ speex_resampler_destroy()

◆ speex_resampler_get_input_latency()

◆ speex_resampler_get_input_stride()

◆ speex_resampler_get_output_latency()

◆ speex_resampler_get_output_stride()

◆ speex_resampler_get_quality()

◆ speex_resampler_get_rate()

◆ speex_resampler_get_ratio()

◆ speex_resampler_init()

◆ speex_resampler_init_frac()

◆ speex_resampler_magic()

◆ speex_resampler_process_float()

◆ speex_resampler_process_int()

◆ speex_resampler_process_interleaved_float()

◆ speex_resampler_process_interleaved_int()

◆ speex_resampler_process_native()

◆ speex_resampler_reset_mem()

◆ speex_resampler_set_input_stride()

◆ speex_resampler_set_output_stride()

◆ speex_resampler_set_quality()

◆ speex_resampler_set_rate()

◆ speex_resampler_set_rate_frac()

◆ speex_resampler_skip_zeros()

◆ speex_resampler_strerror()

◆ update_filter()

Variable Documentation

◆ _KAISER10

◆ _KAISER12

◆ _KAISER6

◆ _KAISER8

◆ kaiser10_table

◆ kaiser12_table

◆ kaiser6_table

◆ kaiser8_table

◆ quality_map