speex_resampler.h File Reference

#include "speex/speex_types.h"

Include dependency graph for speex_resampler.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	SPEEX_RESAMPLER_QUALITY_DEFAULT   4
#define	SPEEX_RESAMPLER_QUALITY_DESKTOP   5
#define	SPEEX_RESAMPLER_QUALITY_MAX   10
#define	SPEEX_RESAMPLER_QUALITY_MIN   0
#define	SPEEX_RESAMPLER_QUALITY_VOIP   3

Typedefs
typedef struct SpeexResamplerState_	SpeexResamplerState

Enumerations
enum	{   RESAMPLER_ERR_SUCCESS = 0 , RESAMPLER_ERR_ALLOC_FAILED = 1 , RESAMPLER_ERR_BAD_STATE = 2 , RESAMPLER_ERR_INVALID_ARG = 3 ,   RESAMPLER_ERR_PTR_OVERLAP = 4 , RESAMPLER_ERR_MAX_ERROR }

Functions
void	speex_resampler_destroy (SpeexResamplerState *st)
int	speex_resampler_get_input_latency (SpeexResamplerState *st)
void	speex_resampler_get_input_stride (SpeexResamplerState *st, spx_uint32_t *stride)
int	speex_resampler_get_output_latency (SpeexResamplerState *st)
void	speex_resampler_get_output_stride (SpeexResamplerState *st, spx_uint32_t *stride)
void	speex_resampler_get_quality (SpeexResamplerState *st, int *quality)
void	speex_resampler_get_rate (SpeexResamplerState *st, spx_uint32_t *in_rate, spx_uint32_t *out_rate)
void	speex_resampler_get_ratio (SpeexResamplerState *st, spx_uint32_t *ratio_num, spx_uint32_t *ratio_den)
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.
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)
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)
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)
int	speex_resampler_process_interleaved_float (SpeexResamplerState *st, const float *in, spx_uint32_t *in_len, float *out, spx_uint32_t *out_len)
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)
int	speex_resampler_reset_mem (SpeexResamplerState *st)
void	speex_resampler_set_input_stride (SpeexResamplerState *st, spx_uint32_t stride)
void	speex_resampler_set_output_stride (SpeexResamplerState *st, spx_uint32_t stride)
int	speex_resampler_set_quality (SpeexResamplerState *st, int quality)
int	speex_resampler_set_rate (SpeexResamplerState *st, spx_uint32_t in_rate, spx_uint32_t out_rate)
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)
int	speex_resampler_skip_zeros (SpeexResamplerState *st)
const char *	speex_resampler_strerror (int err)

Macro Definition Documentation

SPEEX_RESAMPLER_QUALITY_DEFAULT

#define SPEEX_RESAMPLER_QUALITY_DEFAULT   4

Definition at line 97 of file speex_resampler.h.

SPEEX_RESAMPLER_QUALITY_DESKTOP

#define SPEEX_RESAMPLER_QUALITY_DESKTOP   5

Definition at line 99 of file speex_resampler.h.

SPEEX_RESAMPLER_QUALITY_MAX

#define SPEEX_RESAMPLER_QUALITY_MAX   10

Definition at line 95 of file speex_resampler.h.

SPEEX_RESAMPLER_QUALITY_MIN

#define SPEEX_RESAMPLER_QUALITY_MIN   0

Definition at line 96 of file speex_resampler.h.

SPEEX_RESAMPLER_QUALITY_VOIP

#define SPEEX_RESAMPLER_QUALITY_VOIP   3

Definition at line 98 of file speex_resampler.h.

Typedef Documentation

SpeexResamplerState

typedef struct SpeexResamplerState_ SpeexResamplerState

Definition at line 112 of file speex_resampler.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
RESAMPLER_ERR_SUCCESS
RESAMPLER_ERR_ALLOC_FAILED
RESAMPLER_ERR_BAD_STATE
RESAMPLER_ERR_INVALID_ARG
RESAMPLER_ERR_PTR_OVERLAP
RESAMPLER_ERR_MAX_ERROR

Definition at line 101 of file speex_resampler.h.

     {
   RESAMPLER_ERR_SUCCESS         = 0,
   RESAMPLER_ERR_ALLOC_FAILED    = 1,
   RESAMPLER_ERR_BAD_STATE       = 2,
   RESAMPLER_ERR_INVALID_ARG     = 3,
   RESAMPLER_ERR_PTR_OVERLAP     = 4,
 
   RESAMPLER_ERR_MAX_ERROR
};

Function Documentation

speex_resampler_destroy()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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;
}

References SpeexResamplerState_::buffer_size, SpeexResamplerState_::cutoff, SpeexResamplerState_::den_rate, SpeexResamplerState_::filt_len, SpeexResamplerState_::in_rate, SpeexResamplerState_::in_stride, SpeexResamplerState_::initialised, SpeexResamplerState_::last_sample, SpeexResamplerState_::magic_samples, SpeexResamplerState_::mem, SpeexResamplerState_::mem_alloc_size, SpeexResamplerState_::nb_channels, NULL, SpeexResamplerState_::num_rate, SpeexResamplerState_::out_rate, SpeexResamplerState_::out_stride, quality, SpeexResamplerState_::quality, RESAMPLER_ERR_INVALID_ARG, RESAMPLER_ERR_SUCCESS, SpeexResamplerState_::resampler_ptr, SpeexResamplerState_::samp_frac_num, SpeexResamplerState_::sinc_table_length, speex_resampler_destroy(), speex_resampler_set_quality(), speex_resampler_set_rate_frac(), SpeexResamplerState_::started, and update_filter().

Referenced by speex_resampler_init().

speex_resampler_process_float()

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()

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()

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()

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_reset_mem()

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()

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()

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()

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()

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()

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()

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()

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.