自学教程：C++ src_strerror函数代码示例

int samplerate(jack_nframes_t rate, void *arg){  JackCard* obj = (JackCard*) arg;  int error;  obj->rate = rate;  if (obj->read.open) {    obj->read.data.src_ratio = (double)obj->read.rate / (double)obj->rate;    obj->read.data.input_frames = (long)((double)obj->read.frames/obj->read.data.src_ratio);    g_free(obj->read.data.data_in);    obj->read.data.data_in = malloc(obj->read.data.input_frames*sizeof(float));    if (obj->read.src_state)      if ((error = src_set_ratio(obj->read.src_state, obj->read.data.src_ratio)) != 0)	g_warning("Error while resetting the write samplerate: %s", src_strerror(error));  }  if (obj->write.open) {    obj->write.data.src_ratio = (double)obj->rate / (double)obj->write.rate;    obj->write.data.output_frames = (long)((double)obj->write.frames*obj->write.data.src_ratio);    g_free(obj->write.data.data_out);    obj->write.data.data_out = malloc(obj->write.data.output_frames*sizeof(float));    if (obj->write.src_state)       if ((error = src_set_ratio(obj->write.src_state, obj->write.data.src_ratio)) != 0)	g_warning("Error while resetting the write samplerate: %s", src_strerror(error));  }  return 0;}

static voidzero_input_test (int converter){	SRC_DATA data ;	SRC_STATE *state ;	float out [100] ;	int error ;	printf ("    %s (%-26s) ........ ", __func__, src_get_name (converter)) ;	fflush (stdout) ;	if ((state = src_new (converter, 1, &error)) == NULL)	{	printf ("/n/nLine %d : src_new failed : %s./n/n", __LINE__, src_strerror (error)) ;		exit (1) ;		} ;	data.data_in = (float *) 0xdeadbeef ;	data.input_frames = 0 ;	data.data_out = out ;	data.output_frames = ARRAY_LEN (out) ;	data.end_of_input = 0 ;	data.src_ratio = 1.0 ;	if ((error = src_process (state, &data)))	{	printf ("/n/nLine %d : src_new failed : %s./n/n", __LINE__, src_strerror (error)) ;		exit (1) ;		} ;	state = src_delete (state) ;	puts ("ok") ;} /* zero_input_test */

const int32_t *pcm_resample_lsr_32(struct pcm_resample_state *state,		    uint8_t channels,		    unsigned src_rate,		    const int32_t *src_buffer, size_t src_size,		    unsigned dest_rate, size_t *dest_size_r,		    GError **error_r){	bool success;	SRC_DATA *data = &state->data;	size_t data_in_size;	size_t data_out_size;	int error;	int32_t *dest_buffer;	assert((src_size % (sizeof(*src_buffer) * channels)) == 0);	success = pcm_resample_set(state, channels, src_rate, dest_rate,				   error_r);	if (!success)		return NULL;	/* there was an error previously, and nothing has changed */	if (state->error) {		g_set_error(error_r, libsamplerate_quark(), state->error,			    "libsamplerate has failed: %s",			    src_strerror(state->error));		return NULL;	}	data->input_frames = src_size / sizeof(*src_buffer) / channels;	data_in_size = data->input_frames * sizeof(float) * channels;	data->data_in = pcm_buffer_get(&state->in, data_in_size);	data->output_frames = (src_size * dest_rate + src_rate - 1) / src_rate;	data_out_size = data->output_frames * sizeof(float) * channels;	data->data_out = pcm_buffer_get(&state->out, data_out_size);	src_int_to_float_array(src_buffer, data->data_in,			       data->input_frames * channels);	error = src_process(state->state, data);	if (error) {		g_set_error(error_r, libsamplerate_quark(), error,			    "libsamplerate has failed: %s",			    src_strerror(error));		state->error = error;		return NULL;	}	*dest_size_r = data->output_frames_gen *		sizeof(*dest_buffer) * channels;	dest_buffer = pcm_buffer_get(&state->buffer, *dest_size_r);	src_float_to_int_array(data->data_out, dest_buffer,			       data->output_frames_gen * channels);	return dest_buffer;}

static block_t *Resample (filter_t *filter, block_t *in){    block_t *out = NULL;    const size_t framesize = filter->fmt_out.audio.i_bytes_per_frame;    SRC_STATE *s = (SRC_STATE *)filter->p_sys;    SRC_DATA src;    src.src_ratio = (double)filter->fmt_out.audio.i_rate                  / (double)filter->fmt_in.audio.i_rate;    int err = src_set_ratio (s, src.src_ratio);    if (err != 0)    {        msg_Err (filter, "cannot update resampling ratio: %s",                 src_strerror (err));        goto error;    }    src.input_frames = in->i_nb_samples;    src.output_frames = ceil (src.src_ratio * src.input_frames);    src.end_of_input = 0;    out = block_Alloc (src.output_frames * framesize);    if (unlikely(out == NULL))        goto error;    src.data_in = (float *)in->p_buffer;    src.data_out = (float *)out->p_buffer;    err = src_process (s, &src);    if (err != 0)    {        msg_Err (filter, "cannot resample: %s", src_strerror (err));        block_Release (out);        out = NULL;        goto error;    }    if (src.input_frames_used < src.input_frames)        msg_Err (filter, "lost %ld of %ld input frames",                 src.input_frames - src.input_frames_used, src.input_frames);    out->i_buffer = src.output_frames_gen * framesize;    out->i_nb_samples = src.output_frames_gen;    out->i_pts = in->i_pts;    out->i_length = src.output_frames_gen * CLOCK_FREQ                  / filter->fmt_out.audio.i_rate;error:    block_Release (in);    return out;}

int Wave::resample(int quality, int newRate){	float ratio = newRate / (float) inHeader.samplerate;	int newSize = ceil(size * ratio);	if (newSize % 2 != 0)   // libsndfile goes crazy with odd size in case of saving		newSize++;	float *tmp = (float *) malloc(newSize * sizeof(float));	if (!tmp) {		gLog("[wave] unable to allocate memory for resampling/n");		return -1;	}	SRC_DATA src_data;	src_data.data_in       = data;	src_data.input_frames  = size/2;     // in frames, i.e. /2 (stereo)	src_data.data_out      = tmp;	src_data.output_frames = newSize/2;  // in frames, i.e. /2 (stereo)	src_data.src_ratio     = ratio;	gLog("[wave] resampling: new size=%d (%d frames)/n", newSize, newSize/2);	int ret = src_simple(&src_data, quality, 2);	if (ret != 0) {		gLog("[wave] resampling error: %s/n", src_strerror(ret));		return 0;	}	free(data);	data = tmp;	size = newSize;	inHeader.samplerate = newRate;	return 1;}

static voiderror_test (void){	const char *errorstr ;	int		k, errors = 0 ;	puts ("    error_test :") ;	for (k = 0 ; 1 ; k++)	{	errorstr = src_strerror (k) ;		printf ("/t%-2d : %s/n", k, errorstr) ;		if (errorstr == NULL)		{	errors ++ ;			continue ;			} ;		if (strstr (errorstr, "Placeholder.") == errorstr)			break ;		} ;	if (errors != 0)	{	printf ("/n/nLine %d : Missing error numbers above./n/n", __LINE__) ;		exit (1) ;		} ;	puts ("") ;	return ;} /* error_test */

static voidsimple_test (int converter){	int ilen = 199030, olen = 1000, error ;	{		float in [ilen] ;		float out [olen] ;		double ratio = (1.0 * olen) / ilen ;		SRC_DATA src_data =		{	in, out,			ilen, olen,			0, 0, 0,			ratio		} ;		error = src_simple (&src_data, converter, 1) ;		if (error)		{	printf ("/n/nLine %d : %s/n/n", __LINE__, src_strerror (error)) ;			exit (1) ;			} ;	} ;    return ;} /* simple_test */

static doublefind_attenuation (double freq, int converter, int verbose){	static float input	[BUFFER_LEN] ;	static float output [2 * BUFFER_LEN] ;	SRC_DATA	src_data ;	double 		output_peak ;	int			error ;	gen_windowed_sines (input, BUFFER_LEN, &freq, 1) ;	src_data.end_of_input = 1 ; /* Only one buffer worth of input. */	src_data.data_in = input ;	src_data.input_frames = BUFFER_LEN ;	src_data.src_ratio = 1.999 ;	src_data.data_out = output ;	src_data.output_frames = ARRAY_LEN (output) ;	if ((error = src_simple (&src_data, converter, 1)))	{	printf ("/n/nLine %d : %s/n/n", __LINE__, src_strerror (error)) ;		exit (1) ;		} ;	output_peak = find_peak (output, ARRAY_LEN (output)) ;	if (verbose)		printf ("/tFreq : %6f   InPeak : %6f    OutPeak : %6f   Atten : %6.2f dB/n",				freq, 1.0, output_peak, 20.0 * log10 (1.0 / output_peak)) ;	return 20.0 * log10 (1.0 / output_peak) ;} /* find_attenuation */

int jack_card_read(JackCard *obj,char *buf,int size){  size_t bytes, can_read, i;  int error;  float norm, value;  g_return_val_if_fail((obj->read.buffer!=NULL)&&(obj->read.src_state!=NULL),-1);  if (jack_init(obj) != 0) return -1;  size /= 2;  can_read = MIN(size, obj->read.frames);  //  can_read = MIN(((long)((double)can_read / obj->read.data.src_ratio))*sizeof(sample_t), jack_ringbuffer_read_space(obj->read.buffer));  can_read = ((long)((double)can_read / obj->read.data.src_ratio))*sizeof(sample_t);  obj->read.can_process = FALSE;  bytes = jack_ringbuffer_read (obj->read.buffer, (void *)obj->read.data.data_in, can_read);  obj->read.can_process = TRUE;  obj->read.data.input_frames = bytes / sizeof(sample_t);  can_read = MIN(size, obj->read.frames);  obj->read.data.output_frames = can_read;  if ((error = src_process(obj->read.src_state, &(obj->read.data))) != 0)    g_warning("error while samplerate conversion. error: %s", src_strerror(error));  norm = obj->read.level*obj->level*(float)0x8000;  for (i=0; i < obj->read.data.output_frames_gen; i++) {    value = obj->read.data.data_out[i]*norm;    if (value >= 32767.0)       ((short*)buf)[i] = 32767;    else if (value <= -32768.0)      ((short*)buf)[i] = -32768;    else      ((short*)buf)[i] = (short)value;  }  bytes = obj->read.data.output_frames_gen * 2;  return bytes;}

int jack_card_open_w(JackCard *obj,int bits,int stereo,int rate){  int channels = stereo + 1, bsize, err;  obj->write.init = TRUE;  if (jack_init(obj) != 0) return -1;  obj->write.rate = rate;  obj->sample_size = bits / 8;  obj->frame_size = channels * obj->sample_size;  bsize = BSIZE;  obj->write.frames = bsize / 2;  SND_CARD(obj)->bsize = bsize;  SND_CARD(obj)->flags |= SND_CARD_FLAGS_OPENED;  obj->write.channels = channels;  if ((obj->write.src_state = src_new (SRC_SINC_FASTEST, channels, &err)) == NULL)    g_warning("Error while initializing the samplerate converter: %s", src_strerror(err));  obj->write.data.src_ratio = (double)obj->rate / (double)rate;  obj->write.data.data_in = malloc(obj->write.frames*sizeof(float));  obj->write.data.end_of_input = 0;  obj->write.data.output_frames = (long)((double)obj->write.frames*obj->write.data.src_ratio);  obj->write.data.data_out = malloc(obj->write.data.output_frames*sizeof(float));  if (!obj->write.buffer)    obj->write.buffer = jack_ringbuffer_create(WRITEBUFFERSIZE);  obj->write.can_process = TRUE;  obj->can_process = TRUE;  obj->write.open = TRUE;  obj->write.init = FALSE;  return 0;}

void Resample::compute() {  const std::vector<Real>& signal = _signal.get();  std::vector<Real>& resampled = _resampled.get();  if (_factor == 1.0) {    resampled = signal;    return;  }  if (signal.empty()) return;  SRC_DATA src;  src.input_frames = (long)signal.size();  src.data_in = const_cast<float*>(&(signal[0]));  // add some samples to make sure we don't crash in a stupid way...  src.output_frames = (long)((double)signal.size()*_factor + 100.0);  resampled.resize(src.output_frames);  src.data_out = &(resampled[0]);  src.src_ratio = _factor;  // do the conversion  int error = src_simple(&src, _quality, 1);  if (error) throw EssentiaException("Resample: Error in resampling: ", src_strerror(error));  resampled.resize(src.output_frames_gen);}

static int OpenResampler (vlc_object_t *obj){    filter_t *filter = (filter_t *)obj;    /* Only float->float */    if (filter->fmt_in.audio.i_format != VLC_CODEC_FL32     || filter->fmt_out.audio.i_format != VLC_CODEC_FL32    /* No channels remapping */     || filter->fmt_in.audio.i_physical_channels                                  != filter->fmt_out.audio.i_physical_channels     || filter->fmt_in.audio.i_original_channels                                  != filter->fmt_out.audio.i_original_channels)        return VLC_EGENERIC;    int type = var_InheritInteger (obj, "src-converter-type");    int channels = aout_FormatNbChannels (&filter->fmt_in.audio);    int err;    SRC_STATE *s = src_new (type, channels, &err);    if (s == NULL)    {        msg_Err (obj, "cannot initialize resampler: %s", src_strerror (err));        return VLC_EGENERIC;    }    filter->p_sys = (filter_sys_t *)s;    filter->pf_audio_filter = Resample;    return VLC_SUCCESS;}

// Could we get iph-based instruments support sample-exact models by using a// frame-length of 1 while rendering?void sf2Instrument::play( sampleFrame * _working_buffer ){	const fpp_t frames = engine::mixer()->framesPerPeriod();	m_synthMutex.lock();	const int currentMidiPitch = instrumentTrack()->midiPitch();	if( m_lastMidiPitch != currentMidiPitch )	{		m_lastMidiPitch = currentMidiPitch;		fluid_synth_pitch_bend( m_synth, m_channel, m_lastMidiPitch );	}	const int currentMidiPitchRange = instrumentTrack()->midiPitchRange();	if( m_lastMidiPitchRange != currentMidiPitchRange )	{		m_lastMidiPitchRange = currentMidiPitchRange;		fluid_synth_pitch_wheel_sens( m_synth, m_channel, m_lastMidiPitchRange );	}	if( m_internalSampleRate < engine::mixer()->processingSampleRate() &&							m_srcState != NULL )	{		const fpp_t f = frames * m_internalSampleRate / engine::mixer()->processingSampleRate();#ifdef __GNUC__		sampleFrame tmp[f];#else		sampleFrame * tmp = new sampleFrame[f];#endif		fluid_synth_write_float( m_synth, f, tmp, 0, 2, tmp, 1, 2 );		SRC_DATA src_data;		src_data.data_in = tmp[0];		src_data.data_out = _working_buffer[0];		src_data.input_frames = f;		src_data.output_frames = frames;		src_data.src_ratio = (double) frames / f;		src_data.end_of_input = 0;		int error = src_process( m_srcState, &src_data );#ifndef __GNUC__		delete[] tmp;#endif		if( error )		{			qCritical( "sf2Instrument: error while resampling: %s", src_strerror( error ) );		}		if( src_data.output_frames_gen > frames )		{			qCritical( "sf2Instrument: not enough frames: %ld / %d", src_data.output_frames_gen, frames );		}	}	else	{		fluid_synth_write_float( m_synth, frames, _working_buffer, 0, 2, _working_buffer, 1, 2 );	}	m_synthMutex.unlock();	instrumentTrack()->processAudioBuffer( _working_buffer, frames, NULL );}

unsigned int AmAudio::downMix(unsigned int size){  unsigned int s = size;  if(fmt->channels == 2){    stereo2mono(samples.back_buffer(),(unsigned char*)samples,s);    samples.swap();  }#ifdef USE_LIBSAMPLERATE   if (fmt->rate != SYSTEM_SAMPLERATE) {    if (!resample_state) {      int src_error;      // for better quality but more CPU usage, use SRC_SINC_ converters      resample_state = src_new(SRC_LINEAR, 1, &src_error);      if (!resample_state) {	ERROR("samplerate initialization error: ");      }    }    if (resample_state) {      if (resample_buf_samples + PCM16_B2S(s) > PCM16_B2S(AUDIO_BUFFER_SIZE) * 2) {	WARN("resample input buffer overflow! (%d)/n",	     resample_buf_samples + PCM16_B2S(s));      } else {	signed short* samples_s = (signed short*)(unsigned char*)samples;	src_short_to_float_array(samples_s, &resample_in[resample_buf_samples], PCM16_B2S(s));	resample_buf_samples += PCM16_B2S(s);      }            SRC_DATA src_data;      src_data.data_in = resample_in;      src_data.input_frames = resample_buf_samples;      src_data.data_out = resample_out;      src_data.output_frames = PCM16_B2S(AUDIO_BUFFER_SIZE);      src_data.src_ratio = (double)SYSTEM_SAMPLERATE / (double)fmt->rate;      src_data.end_of_input = 0;      int src_err = src_process(resample_state, &src_data);      if (src_err) {	DBG("resample error: '%s'/n", src_strerror(src_err));      }else {	signed short* samples_s = (signed short*)(unsigned char*)samples;	src_float_to_short_array(resample_out, samples_s, src_data.output_frames_gen);	s = PCM16_S2B(src_data.output_frames_gen);	if (resample_buf_samples !=  (unsigned int)src_data.input_frames_used) {	  memmove(resample_in, &resample_in[src_data.input_frames_used], 		  (resample_buf_samples - src_data.input_frames_used) * sizeof(float));	}	resample_buf_samples = resample_buf_samples - src_data.input_frames_used;      }    }  }#endif   return s;}

static voidsimple_test (int converter, double src_ratio){	static float input [BUFFER_LEN], output [BUFFER_LEN] ;	SRC_DATA	src_data ;	int input_len, output_len, error, terminate ;	printf ("/tsimple_test      (SRC ratio = %6.4f) ........... ", src_ratio) ;	fflush (stdout) ;	/* Calculate maximun input and output lengths. */	if (src_ratio >= 1.0)	{	output_len = BUFFER_LEN ;		input_len = (int) floor (BUFFER_LEN / src_ratio) ;		}	else	{	input_len = BUFFER_LEN ;		output_len = (int) floor (BUFFER_LEN * src_ratio) ;		} ;	/* Reduce input_len by 10 so output is longer than necessary. */	input_len -= 10 ;	if (output_len > BUFFER_LEN)	{	printf ("/n/nLine %d : output_len > BUFFER_LEN/n/n", __LINE__) ;		exit (1) ;		} ;	memset (&src_data, 0, sizeof (src_data)) ;	src_data.data_in = input ;	src_data.input_frames = input_len ;	src_data.src_ratio = src_ratio ;	src_data.data_out = output ;	src_data.output_frames = BUFFER_LEN ;	if ((error = src_simple (&src_data, converter, 1)))	{	printf ("/n/nLine %d : %s/n/n", __LINE__, src_strerror (error)) ;		exit (1) ;		} ;	terminate = (int) ceil ((src_ratio >= 1.0) ? src_ratio : 1.0 / src_ratio) ;	if (fabs (src_data.output_frames_gen - src_ratio * input_len) > 2 * terminate)	{	printf ("/n/nLine %d : bad output data length %ld should be %d./n", __LINE__,					src_data.output_frames_gen, (int) floor (src_ratio * input_len)) ;		printf ("/tsrc_ratio  : %.4f/n", src_ratio) ;		printf ("/tinput_len  : %d/n/toutput_len : %d/n/n", input_len, output_len) ;		exit (1) ;		} ;	puts ("ok") ;	return ;} /* simple_test */

unsigned int AmLibSamplerateResamplingState::resample(unsigned char* samples, unsigned int s, double ratio){  DBG("resampling packet of size %d with ratio %f", s, ratio);  if (!resample_state) {    int src_error;    // for better quality but more CPU usage, use SRC_SINC_ converters    resample_state = src_new(SRC_LINEAR, 1, &src_error);    if (!resample_state) {      ERROR("samplerate initialization error: ");    }  }  if (resample_state) {    if (resample_buf_samples + PCM16_B2S(s) > PCM16_B2S(AUDIO_BUFFER_SIZE) * 2) {      WARN("resample input buffer overflow! (%lu)/n", resample_buf_samples + PCM16_B2S(s));    } else if (resample_out_buf_samples + (PCM16_B2S(s) * ratio) + 20 > PCM16_B2S(AUDIO_BUFFER_SIZE)) {      WARN("resample: possible output buffer overflow! (%lu)/n", (resample_out_buf_samples + (size_t) ((PCM16_B2S(s) * ratio)) + 20));    } else {      signed short* samples_s = (signed short*)samples;      src_short_to_float_array(samples_s, &resample_in[resample_buf_samples], PCM16_B2S(s));      resample_buf_samples += PCM16_B2S(s);    }    SRC_DATA src_data;    src_data.data_in = resample_in;    src_data.input_frames = resample_buf_samples;    src_data.data_out = &resample_out[resample_out_buf_samples];    src_data.output_frames = PCM16_B2S(AUDIO_BUFFER_SIZE);    src_data.src_ratio = ratio;    src_data.end_of_input = 0;    int src_err = src_process(resample_state, &src_data);    if (src_err) {      DBG("resample error: '%s'/n", src_strerror(src_err));    }else {      signed short* samples_s = (signed short*)(unsigned char*)samples;      resample_out_buf_samples += src_data.output_frames_gen;      s *= ratio;      src_float_to_short_array(resample_out, samples_s, PCM16_B2S(s));      DBG("resample: output_frames_gen = %ld", src_data.output_frames_gen);      if (resample_buf_samples !=  (unsigned int)src_data.input_frames_used) {	memmove(resample_in, &resample_in[src_data.input_frames_used],		(resample_buf_samples - src_data.input_frames_used) * sizeof(float));      }      resample_buf_samples = resample_buf_samples - src_data.input_frames_used;      if (resample_out_buf_samples != s) {	memmove(resample_out, &resample_out[PCM16_B2S(s)], (resample_out_buf_samples - PCM16_B2S(s)) * sizeof(float));      }      resample_out_buf_samples -= PCM16_B2S(s);    }  }  DBG("resample: output size is %d", s);  return s;}

void* decOpen(	const char* inputurl,	size_t* bitspersample,	size_t* channels,	size_t* samplerate){	int i;	for(i = 0; decoders[i].open != NULL ; i++)	{		int err;		void* data;		dec_data* ret;		if((data = decoders[i].open(			inputurl,			bitspersample, 			channels,			samplerate,			&err)) == NULL)		{			if(err != INVALID_FORMAT)				return NULL;			else				continue;		} 			if((ret = (dec_data*)malloc(sizeof(dec_data))) == NULL)		{			decoders[i].close(data);			return NULL;		}		ret->decoder = &decoders[i];		ret->data    = data;			if((ret->converter = src_new(SRC_LINEAR, audio_channels, &err)) == NULL)		{			LOG(L"libsamplerate: " MB_FORMAT "/n", src_strerror(err));				decoders[i].close(data);			free(ret);						return NULL;		}				ret->ratio = ((double)audio_samplerate / (double)*samplerate);		src_set_ratio((SRC_STATE*)ret->converter, ret->ratio);				ret->samplerate = *samplerate;		ret->channels   = *channels;				return ret;	}	return NULL;}

//***************************************************************************Kwave::RateConverter::RateConverter()    :Kwave::SampleSource(), m_ratio(1.0), m_converter(0),     m_converter_in(), m_converter_out(){    int error = 0;    m_converter = src_new(SRC_SINC_MEDIUM_QUALITY, 1, &error);    Q_ASSERT(m_converter);    if (!m_converter) qWarning("creating converter failed: '%s",	src_strerror(error));}

int krad_opus_decoder_read (krad_opus_t *krad_opus, int channel, char *buffer, int buffer_length) {		int resample_process_size = 512;	krad_opus->ret = krad_ringbuffer_peek (krad_opus->resampled_ringbuf[channel - 1], (char *)buffer, buffer_length );	if (krad_opus->ret >= buffer_length) {		krad_ringbuffer_read_advance (krad_opus->resampled_ringbuf[channel - 1], buffer_length );		return krad_opus->ret;	} else {		while (krad_ringbuffer_read_space (krad_opus->resampled_ringbuf[channel - 1]) < buffer_length) {			if (krad_ringbuffer_read_space (krad_opus->ringbuf[channel - 1]) >= resample_process_size * 4 ) {				krad_opus->ret = krad_ringbuffer_peek (krad_opus->ringbuf[channel - 1],											  (char *)krad_opus->read_samples[channel - 1],											          (resample_process_size * 4) );							krad_opus->src_data[channel - 1].data_in = krad_opus->read_samples[channel - 1];				krad_opus->src_data[channel - 1].input_frames = resample_process_size;				krad_opus->src_data[channel - 1].data_out = krad_opus->resampled_samples[channel - 1];				krad_opus->src_data[channel - 1].output_frames = 2048;				krad_opus->src_error[channel - 1] = src_process (krad_opus->src_resampler[channel - 1],																&krad_opus->src_data[channel - 1]);				if (krad_opus->src_error[channel - 1] != 0) {					failfast ("krad_opus_read_audio src resampler error: %s/n",							  src_strerror(krad_opus->src_error[channel - 1]));				}								krad_ringbuffer_read_advance (krad_opus->ringbuf[channel - 1],											 (krad_opus->src_data[channel - 1].input_frames_used * 4) );				krad_opus->ret = krad_ringbuffer_write (krad_opus->resampled_ringbuf[channel - 1],				                               (char *)krad_opus->resampled_samples[channel - 1],				                                       (krad_opus->src_data[channel - 1].output_frames_gen * 4) );				if (krad_ringbuffer_read_space (krad_opus->resampled_ringbuf[channel - 1]) >= buffer_length ) {					return krad_ringbuffer_read (krad_opus->resampled_ringbuf[channel - 1], buffer, buffer_length );				}			} else {				return 0;			}				}			}		return 0;	}

JNIEXPORT jint JNICALL Java_org_sipdroid_media_file_AudioFile_nresample(JNIEnv* env, jobject obj, jdouble ratio, jshortArray inBuffer, jshortArray outBuffer){	if(ready){		pthread_mutex_lock(&lock);		// initialize converter		if(converter == NULL){			int error;			converter = src_new(SRC_SINC_MEDIUM_QUALITY, 1, &error);			if(converter == NULL){				__android_log_print(ANDROID_LOG_DEBUG, DEBUG_TAG, "unable to initialize sample rate converter: %s", src_strerror(error));				pthread_mutex_unlock(&lock);				return -1;			}		}		// prepare buffers		jint input_len = env->GetArrayLength(inBuffer);		float* fl_inBuffer = (float*) malloc(input_len * sizeof(float));		short* sh_inBuffer = env->GetShortArrayElements(inBuffer, NULL);		src_short_to_float_array(sh_inBuffer, fl_inBuffer, input_len);		env->ReleaseShortArrayElements(inBuffer, sh_inBuffer, 0);		jint output_len = env->GetArrayLength(outBuffer);		float* fl_outBuffer = (float*) malloc(sizeof(float) * output_len);		SRC_DATA src_data;		src_data.data_in = fl_inBuffer;		src_data.input_frames = (long) input_len;		src_data.data_out = fl_outBuffer;		src_data.output_frames = (long) output_len;		src_data.src_ratio = (double) 1/ratio;		src_data.end_of_input = 0;		// resample		int error;		if ((error = src_process(converter, &src_data)) >= 0){			// convert output to float and write to outBuffer			short* sh_outBuffer = env->GetShortArrayElements(outBuffer, NULL);			src_float_to_short_array(src_data.data_out, sh_outBuffer, src_data.output_frames_gen);			env->ReleaseShortArrayElements(outBuffer, sh_outBuffer, 0);		}		else{			__android_log_print(ANDROID_LOG_DEBUG, DEBUG_TAG, "resampling error: %s", src_strerror(error));		}		free(fl_outBuffer);		free(fl_inBuffer);		pthread_mutex_unlock(&lock);		return src_data.output_frames_gen;	}	return 0;}

static boollsr_process(struct pcm_resample_state *state, GError **error_r){	if (state->error == 0)		state->error = src_process(state->state, &state->data);	if (state->error) {		g_set_error(error_r, libsamplerate_quark(), state->error,			    "libsamplerate has failed: %s",			    src_strerror(state->error));		return false;	}	return true;}

aubio_resampler_t *new_aubio_resampler (smpl_t ratio, uint_t type){  aubio_resampler_t *s = AUBIO_NEW (aubio_resampler_t);  int error = 0;  s->stat = src_new (type, 1, &error);  /* only one channel */  if (error) {    AUBIO_ERR ("Failed creating resampler: %s/n", src_strerror (error));    del_aubio_resampler(s);    return NULL;  }  s->proc = AUBIO_NEW (SRC_DATA);  s->ratio = ratio;  return s;}

void AudioBuffer::convert_rate(AudioBuffer &_dest, unsigned _frames_count, SRC_STATE *_SRC){	AudioSpec destspec{AUDIO_FORMAT_F32, m_spec.channels, _dest.rate()};	if(m_spec.format != AUDIO_FORMAT_F32 || _dest.spec() != destspec) {		throw std::logic_error("unsupported format");	}	_frames_count = std::min(frames(),_frames_count);	double rate_ratio = double(destspec.rate)/double(m_spec.rate);	unsigned out_frames = unsigned(ceil(double(_frames_count) * rate_ratio));	if(out_frames==0) {		return;	}	unsigned destpos = _dest.samples();	unsigned destframes = _dest.frames();	_dest.resize_frames(_dest.frames()+out_frames);#if HAVE_LIBSAMPLERATE	SRC_DATA srcdata;	srcdata.data_in = &at<float>(0);	srcdata.data_out = &_dest.at<float>(destpos);	srcdata.input_frames = _frames_count;	srcdata.output_frames = out_frames;	srcdata.src_ratio = rate_ratio;	int srcresult;	if(_SRC != nullptr) {		srcdata.end_of_input = 0;		srcresult = src_process(_SRC, &srcdata);	} else {		srcdata.end_of_input = 1;		srcresult = src_simple(&srcdata, SRC_SINC_BEST_QUALITY, destspec.channels) ;	}	if(srcresult != 0) {		throw std::runtime_error(std::string("error resampling: ") + src_strerror(srcresult));	}	assert(srcdata.output_frames_gen>=0 && srcdata.output_frames_gen<=out_frames);	if(srcdata.output_frames_gen != out_frames) {		_dest.resize_frames(destframes + srcdata.output_frames_gen);	}	PDEBUGF(LOG_V2, LOG_MIXER, "convert rate: f-in: %d, f-out: %d, gen: %d/n",			_frames_count, out_frames, srcdata.output_frames_gen);#else	for(unsigned i=destpos; i<_dest.samples(); ++i) {		_dest.operator[]<float>(i) = 0.f;	}#endif}

static FLAC__StreamDecoderWriteStatus flac_writer_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const inputbuffer[], void *client_data)    {    struct xlplayer *xlplayer = client_data;    struct flacdecode_vars *self = xlplayer->dec_data;    SRC_DATA *src_data = &(xlplayer->src_data);    int src_error;    if (self->suppress_audio_output == FALSE)        {        if (xlplayer->src_state)            {            if (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER && frame->header.number.frame_number == 0)                {                fprintf(stderr, "flac_writer_callback: performance warning -- can't determine if a block is the last one or not for this file/n");                }            else                {                if (frame->header.number.sample_number + frame->header.blocksize == self->totalsamples)                    src_data->end_of_input = TRUE;                }            src_data->input_frames = frame->header.blocksize;            src_data->data_in = realloc(src_data->data_in, src_data->input_frames * frame->header.channels * sizeof (float));            src_data->output_frames = (int)(src_data->input_frames * src_data->src_ratio) + 2 + (512 * src_data->end_of_input);            src_data->data_out = realloc(src_data->data_out, src_data->output_frames * frame->header.channels * sizeof (float));            make_flac_audio_to_float(xlplayer, src_data->data_in, inputbuffer, frame->header.blocksize, frame->header.bits_per_sample, frame->header.channels);            if ((src_error = src_process(xlplayer->src_state, src_data)))                {                fprintf(stderr, "flac_writer_callback: src_process reports %s/n", src_strerror(src_error));                xlplayer->playmode = PM_EJECTING;                return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;                }            xlplayer_demux_channel_data(xlplayer, src_data->data_out, src_data->output_frames_gen, frame->header.channels, 1.f);            }        else            {            if ((self->flbuf = realloc(self->flbuf, sizeof (float) * frame->header.blocksize * frame->header.channels)) == NULL)                {                fprintf(stderr, "flac_writer_callback: malloc failure/n");                xlplayer->playmode = PM_EJECTING;                return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;                }            make_flac_audio_to_float(xlplayer, self->flbuf, inputbuffer, frame->header.blocksize, frame->header.bits_per_sample, frame->header.channels);            xlplayer_demux_channel_data(xlplayer, self->flbuf, frame->header.blocksize, frame->header.channels, 1.f);            }        xlplayer_write_channel_data(xlplayer);        }    return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;    }

static boolpcm_resample_set(struct pcm_resample_state *state,		 uint8_t channels, unsigned src_rate, unsigned dest_rate,		 GError **error_r){	static int convalgo = -1;	int error;	SRC_DATA *data = &state->data;	if (convalgo < 0)		convalgo = pcm_resample_get_converter();	/* (re)set the state/ratio if the in or out format changed */	if (channels == state->prev.channels &&	    src_rate == state->prev.src_rate &&	    dest_rate == state->prev.dest_rate)		return true;	state->error = 0;	state->prev.channels = channels;	state->prev.src_rate = src_rate;	state->prev.dest_rate = dest_rate;	if (state->state)		state->state = src_delete(state->state);	state->state = src_new(convalgo, channels, &error);	if (!state->state) {		g_set_error(error_r, libsamplerate_quark(), state->error,			    "libsamplerate initialization has failed: %s",			    src_strerror(error));		return false;	}	data->src_ratio = (double)dest_rate / (double)src_rate;	g_debug("setting samplerate conversion ratio to %.2lf",		data->src_ratio);	src_set_ratio(state->state, data->src_ratio);	return true;}

void sf2Instrument::renderFrames( f_cnt_t frames, sampleFrame * buf ){	m_synthMutex.lock();	if( m_internalSampleRate < Engine::mixer()->processingSampleRate() &&							m_srcState != NULL )	{		const fpp_t f = frames * m_internalSampleRate / Engine::mixer()->processingSampleRate();#ifdef __GNUC__		sampleFrame tmp[f];#else		sampleFrame * tmp = new sampleFrame[f];#endif		fluid_synth_write_float( m_synth, f, tmp, 0, 2, tmp, 1, 2 );		SRC_DATA src_data;		src_data.data_in = (float *)tmp;		src_data.data_out = (float *)buf;		src_data.input_frames = f;		src_data.output_frames = frames;		src_data.src_ratio = (double) frames / f;		src_data.end_of_input = 0;		int error = src_process( m_srcState, &src_data );#ifndef __GNUC__		delete[] tmp;#endif		if( error )		{			qCritical( "sf2Instrument: error while resampling: %s", src_strerror( error ) );		}		if( src_data.output_frames_gen > frames )		{			qCritical( "sf2Instrument: not enough frames: %ld / %d", src_data.output_frames_gen, frames );		}	}	else	{		fluid_synth_write_float( m_synth, frames, buf, 0, 2, buf, 1, 2 );	}	m_synthMutex.unlock();}

int jack_card_write(JackCard *obj,char *buf,int size){  size_t bytes, can_write, i;  int error;  float norm;  g_return_val_if_fail((obj->write.buffer!=NULL)&&(obj->write.src_state!=NULL),-1);  if (jack_init(obj) != 0) return -1;  size /= 2;  can_write = MIN(size, obj->write.frames);  norm = obj->write.level*obj->level/(float)0x8000;  for (i=0; i<can_write; i++) {    obj->write.data.data_in[i] = (float)((short*)buf)[i]*norm;  }  obj->write.data.input_frames = can_write;  if ((error = src_process(obj->write.src_state, &(obj->write.data))) != 0)    g_warning("error while samplerate conversion. error: %s", src_strerror(error));  obj->write.can_process = FALSE;  bytes = jack_ringbuffer_write (obj->write.buffer, (void *) obj->write.data.data_out, sizeof(sample_t)*obj->write.data.output_frames_gen);  obj->write.can_process = TRUE;  return bytes;}

void* fx_resample_init(int channels, int sr_from, int sr_to){    assert(channels >= 1 && channels <= MAX_CHANNELS);    int err = 0;    struct fx_resampler* r = util_malloc(sizeof(struct fx_resampler));    r->channels = channels;    r->ratio    = (double)sr_to / sr_from;    if (!src_is_valid_ratio(r->ratio))        goto error;    for (int ch = 0; ch < channels; ch++) {        r->state[ch] = src_new(SRC_SINC_FASTEST, 1, &err);        if (err)            goto error;    }    LOG_DEBUG("[resample] init, %d channels, %f ratio", channels, r->ratio);    return r;error:    LOG_ERROR("[resample] init failed (%s)", src_strerror(err));    fx_resample_free(r);    return NULL;}

void Effect::resample( int _i, const sampleFrame * _src_buf,							sample_rate_t _src_sr,				sampleFrame * _dst_buf, sample_rate_t _dst_sr,								f_cnt_t _frames ){	if( m_srcState[_i] == NULL )	{		return;	}	m_srcData[_i].input_frames = _frames;	m_srcData[_i].output_frames = Engine::mixer()->framesPerPeriod();	m_srcData[_i].data_in = (float *) _src_buf[0];	m_srcData[_i].data_out = _dst_buf[0];	m_srcData[_i].src_ratio = (double) _dst_sr / _src_sr;	m_srcData[_i].end_of_input = 0;	int error;	if( ( error = src_process( m_srcState[_i], &m_srcData[_i] ) ) )	{		qFatal( "Effect::resample(): error while resampling: %s/n",							src_strerror( error ) );	}}