void snd_reset_samplerate_conv(int rec_or_stream) { int error; if (rec_or_stream == SND_STREAM) { if (srconv_state_stream != NULL) { src_delete(srconv_state_stream); srconv_state_stream = NULL; } srconv_state_stream = src_new(cfg.audio.resample_mode, cfg.audio.channel, &error); if (srconv_state_stream == NULL) { print_info(_("ERROR: Could not initialize samplerate converter"), 0); } } if (rec_or_stream == SND_REC) { if (srconv_state_record != NULL) { src_delete(srconv_state_record); srconv_state_record = NULL; } srconv_state_record = src_new(cfg.audio.resample_mode, cfg.audio.channel, &error); if (srconv_state_record == NULL) { print_info(_("ERROR: Could not initialize samplerate converter"), 0); } } }
static void zero_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 */
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; }
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; }
static int pcm_src_init(void *obj, snd_pcm_rate_info_t *info) { struct rate_src *rate = obj; int err; if (! rate->state || rate->channels != info->channels) { if (rate->state) src_delete(rate->state); rate->channels = info->channels; rate->state = src_new(rate->converter, rate->channels, &err); if (! rate->state) return -EINVAL; } rate->ratio = (double)info->out.rate / (double)info->in.rate; free(rate->src_buf); rate->src_buf = malloc(sizeof(float) * rate->channels * info->in.period_size); free(rate->dst_buf); rate->dst_buf = malloc(sizeof(float) * rate->channels * info->out.period_size); if (! rate->src_buf || ! rate->dst_buf) { pcm_src_free(rate); return -ENOMEM; } rate->data.data_in = rate->src_buf; rate->data.data_out = rate->dst_buf; rate->data.src_ratio = rate->ratio; rate->data.end_of_input = 0; return 0; }
SDLAudioDevice::SDLAudioDevice(IBus *bus) : _state(src_new(SRC_LINEAR, 1, &_error)) , _bus(bus) { memset(_in.data(), 0, BUFFER_SIZE * sizeof(float)); memset(_out.data(), 0, BUFFER_SIZE * sizeof(float)); SDL_InitSubSystem(SDL_INIT_AUDIO); SDL_AudioSpec obtained, desired; SDL_zero(desired); desired.freq = 44800; desired.format = AUDIO_S16LSB; desired.channels = 1; desired.samples = AUDIO_BUFFER_SIZE * 2; desired.callback = audio_callback; desired.userdata = this; _device = SDL_OpenAudioDevice(NULL, 0, &desired, &obtained, 0); // FIXME: handle different configurations if (_device == 0) { std::cerr << "Couldn't open audio device: " << SDL_GetError() << "\n"; throw 0; } else { std::cout << obtained.freq << '\n'; } }
int VPOutPluginDummy::init(VPlayer *v, VPBuffer *in) { DBG("Dummy:init"); owner = v; bin = in; out_srate = 48000; in_srate = bin->srate; int rerr; rs = src_new(SRC_SINC_FASTEST, bin->chans, &rerr); if (!rs){ DBG("SRC error"<<rerr); return -1; } rd.src_ratio = (out_srate*1.0d)/(in_srate*1.0d); out_frames = (VPBUFFER_FRAMES*rd.src_ratio)*2; out_buf = (float *)malloc(out_frames*sizeof(float)*bin->chans); DBG("target rate "<<out_srate); work = true; paused = false; pause_check = false; FULL_MEMORY_BARRIER; worker = new std::thread((void(*)(void*))worker_run, this); DBG("Dummy thread made"); return 0; }
static gboolean xmms_vocoder_init (xmms_xform_t *xform) { xmms_vocoder_data_t *priv; xmms_config_property_t *config; g_return_val_if_fail (xform, FALSE); priv = g_new0 (xmms_vocoder_data_t, 1); priv->winsize = 2048; priv->channels = xmms_xform_indata_get_int (xform, XMMS_STREAM_TYPE_FMT_CHANNELS); priv->bufsize = priv->winsize * priv->channels; priv->iobuf = g_malloc (priv->bufsize * sizeof (gint16)); priv->procbuf = g_malloc (priv->bufsize * sizeof (pvocoder_sample_t)); priv->resbuf = g_malloc (priv->bufsize * sizeof (gfloat)); priv->outbuf = g_string_new (NULL); priv->pvoc = pvocoder_init (priv->winsize, priv->channels); g_return_val_if_fail (priv->pvoc, FALSE); priv->resampler = src_new (SRC_LINEAR, priv->channels, NULL); g_return_val_if_fail (priv->resampler, FALSE); xmms_xform_private_data_set (xform, priv); config = xmms_xform_config_lookup (xform, "enabled"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_vocoder_config_changed, priv); priv->enabled = !!xmms_config_property_get_int (config); config = xmms_xform_config_lookup (xform, "speed"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_vocoder_config_changed, priv); priv->speed = (gfloat) xmms_config_property_get_int (config) / 100.0; config = xmms_xform_config_lookup (xform, "pitch"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_vocoder_config_changed, priv); priv->pitch = 100.0 / (gfloat) xmms_config_property_get_int (config); config = xmms_xform_config_lookup (xform, "attack_detection"); g_return_val_if_fail (config, FALSE); xmms_config_property_callback_set (config, xmms_vocoder_config_changed, priv); priv->attack_detection = !!xmms_config_property_get_int (config); pvocoder_set_scale (priv->pvoc, priv->speed * priv->pitch); pvocoder_set_attack_detection (priv->pvoc, priv->attack_detection); priv->resdata.data_in = NULL; priv->resdata.input_frames = 0; priv->resdata.data_out = priv->resbuf; priv->resdata.output_frames = priv->winsize; priv->resdata.src_ratio = priv->pitch; priv->resdata.end_of_input = 0; xmms_xform_outdata_type_copy (xform); return TRUE; }
HRESULT CSampleRateConverter::SetupConversion() { m_nFrameSize = m_pInputFormat->Format.nBlockAlign; m_dSampleRateRation = (double)m_pOutputFormat->Format.nSamplesPerSec / (double)m_pInputFormat->Format.nSamplesPerSec; if (m_pSrcState) m_pSrcState = src_delete(m_pSrcState); int error = 0; m_pSrcState = src_new(m_pSettings->m_nResamplingQuality, m_pInputFormat->Format.nChannels, &error); m_llFramesInput = 0; m_llFramesOutput = 0; // TODO better error handling if (error != 0) return S_FALSE; Log("CSampleRateConverter::SetupConversion"); LogWaveFormat(m_pInputFormat, "Input format "); LogWaveFormat(m_pOutputFormat, "Output format "); return S_OK; }
SampleChannel::SampleChannel(int bufferSize, char side) : Channel (CHANNEL_SAMPLE, STATUS_EMPTY, side, bufferSize), frameRewind (-1), wave (NULL), tracker (0), begin (0), end (0), pitch (gDEFAULT_PITCH), boost (1.0f), mode (DEFAULT_CHANMODE), qWait (false), fadeinOn (false), fadeinVol (1.0f), fadeoutOn (false), fadeoutVol (1.0f), fadeoutTracker (0), fadeoutStep (DEFAULT_FADEOUT_STEP), key (0), readActions (true), midiInReadActions(0x0), midiInPitch (0x0) { rsmp_state = src_new(SRC_LINEAR, 2, NULL); pChan = (float *) malloc(kernelAudio::realBufsize * 2 * sizeof(float)); }
void alloc_ports( int n_capture, int n_playback ) { int port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal; int chn; jack_port_t *port; char buf[32]; capture_ports = NULL; for (chn = 0; chn < n_capture; chn++) { snprintf (buf, sizeof(buf) - 1, "capture_%u", chn+1); port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0); if (!port) { printf( "jacknet_client: cannot register port for %s", buf); break; } capture_srcs = jack_slist_append( capture_srcs, src_new( 4-samplerate_quality, 1, NULL ) ); capture_ports = jack_slist_append (capture_ports, port); } port_flags = JackPortIsInput; playback_ports = NULL; for (chn = 0; chn < n_playback; chn++) { snprintf (buf, sizeof(buf) - 1, "playback_%u", chn+1); port = jack_port_register (client, buf, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0); if (!port) { printf( "jacknet_client: cannot register port for %s", buf); break; } playback_srcs = jack_slist_append( playback_srcs, src_new( 4-samplerate_quality, 1, NULL ) ); playback_ports = jack_slist_append (playback_ports, port); } }
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; }
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; }
static int init_src(void) { int err; if (fancy_resampling) src = src_new(SRC_SINC_MEDIUM_QUALITY, 2, &err); else src = NULL; return err; }
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; }
//*************************************************************************** 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)); }
SamplerateConverter::SamplerateConverter (int freq) : _maxFreq(freq) { int err; _src_state = src_new (SRC_LINEAR, 1, &err); _samples = (freq * 20) / 1000; // start with 20 ms buffers _floatBufferIn = new float32[_samples]; _floatBufferOut = new float32[_samples]; }
int LV2convolv::resample_read_presets (const float *in, unsigned int in_frames, const int sample_rate, float **buf, unsigned int *n_ch, unsigned int *n_sp) { float resample_ratio = 1.0; if (n_ch) *n_ch = PRESETS_CH; if (n_sp) *n_sp = in_frames; if (sample_rate != PRESETS_SAMPLERATE) { fprintf(stderr, "convolution: samplerate mismatch preset:%d host:%d\n", PRESETS_SAMPLERATE, sample_rate); resample_ratio = (float) sample_rate / (float) PRESETS_SAMPLERATE; } if (buf) { const size_t frames_in = PRESETS_CH * in_frames; const size_t frames_out = PRESETS_CH * ceil(in_frames * resample_ratio); *buf = (float*) malloc(frames_out*sizeof(float)); float *iin; if (resample_ratio != 1.0) { iin = (float*)malloc(frames_in * sizeof(float)); memcpy(iin, in, frames_in * sizeof(float)); } else { memcpy(*buf, in, frames_in * sizeof(float)); } if (!*buf) { fprintf (stderr, "convolution: memory allocation failed for IR audio-file buffer.\n"); return (-2); } if (resample_ratio != 1.0) { VERBOSE_printf("convolution: resampling IR %ld -> %ld [frames * channels].\n", (long int) frames_in, (long int) frames_out); SRC_STATE* src_state = src_new(SRC_QUALITY, PRESETS_CH, NULL); SRC_DATA src_data; src_data.input_frames = in_frames; src_data.output_frames = in_frames * resample_ratio; src_data.end_of_input = 1; src_data.src_ratio = resample_ratio; src_data.input_frames_used = 0; src_data.output_frames_gen = 0; src_data.data_in = iin; src_data.data_out = *buf; src_process(src_state, &src_data); VERBOSE_printf("convolution: resampled IR %ld -> %ld [frames * channels].\n", src_data.input_frames_used * PRESETS_CH, src_data.output_frames_gen * PRESETS_CH); if (n_sp) *n_sp = (unsigned int) src_data.output_frames_gen; free(iin); } } return (0); }
ResampleSRC::ResampleSRC(int c) : Resample(c) , state(NULL) { state = new SRC_STATE *[c]; for(int i = 0; i < c; ++i) { int error; state[i] = src_new(SRC_ZERO_ORDER_HOLD,1,&error); if(!state[i]) post("src init error %i",error); } }
void CDVDPlayerResampler::CheckResampleBuffers(int channels) { int error; if (channels != m_nrchannels) { Clean(); m_nrchannels = channels; m_converter = src_new(m_quality, m_nrchannels, &error); } }
SamplerateConverter::SamplerateConverter(int freq) : floatBufferIn_(0), floatBufferOut_(0), samples_(0), maxFreq_(freq), src_state_(0) { int err; src_state_ = src_new(SRC_LINEAR, 1, &err); samples_ = (freq * 20) / 1000; // start with 20 ms buffers floatBufferIn_ = new float[samples_]; floatBufferOut_ = new float[samples_]; }
void Resample::configure() { int quality = parameter("quality").toInt(); Real factor = parameter("outputSampleRate").toReal() / parameter("inputSampleRate").toReal(); if (_state) src_delete(_state); int nChannels = 1; _state = src_new(quality, nChannels, &_errorCode); _data.src_ratio = factor; reset(); }
void play(){ int num_channels=getSourceNumChannels(); if(isinitialized==false || num_channels==0) return; if(isusingjack==false && audioDeviceManager.getCurrentAudioDevice()==NULL) return; stop(); GUI_newprocess(source_init); //source_init(); //fprintf(stderr,"GUI_newprocess finished\n"); #if 0 if(isusingjack==false){ if(audioDeviceManager.getOutputChannels().countNumberOfSetBits()!=getSourceNumChannels()){ if(num_channels==1) num_channels=2; outchannels=new BitArray(0); for(int lokke=0;lokke<num_channels;lokke++) outchannels->setBit(lokke); audioDeviceManager.setAudioDevice( audioDeviceManager.getAvailableAudioDeviceNames()[0], 1024, R, new BitArray(0), outchannels, false); } } #endif { int error; for(int i=0;i<num_src_states;i++) src_delete(src_states[i]); free(src_states); src_states=(SRC_STATE**)malloc(sizeof(SRC_STATE*)*num_channels); for(int ch=0;ch<num_channels;ch++) src_states[ch]=src_new(SRC_QUALITY,1,&error); } pleasestop=false; jp_playpos=0; mustrunonemore=false; jp_isplaying=true; isreadingdata=true; }
SampleBuffer::handleState::handleState( bool _varying_pitch, int interpolation_mode ) : m_frameIndex( 0 ), m_varyingPitch( _varying_pitch ), m_isBackwards( false ) { int error; m_interpolationMode = interpolation_mode; if( ( m_resamplingData = src_new( interpolation_mode, DEFAULT_CHANNELS, &error ) ) == NULL ) { qDebug( "Error: src_new() failed in sample_buffer.cpp!\n" ); } }
int freedv_create() { pthread_mutex_init(&mutex, NULL); int src_error; insrc1 = src_new(SRC_SINC_FASTEST, 1, &src_error); fdmdv = fdmdv_create(); codec2 = codec2_create(CODEC2_MODE_1400); output_buf = (short*)malloc(2*sizeof(short)*codec2_samples_per_frame(codec2)); return 1; }
void Resampler::resample(const AudioBuffer &dataIn, AudioBuffer &dataOut) { const double inputFreq = dataIn.getSampleRate(); const double outputFreq = dataOut.getSampleRate(); const double sampleFactor = outputFreq / inputFreq; if (sampleFactor == 1.0) return; const size_t nbFrames = dataIn.frames(); const size_t nbChans = dataIn.channels(); if (nbChans != format_.nb_channels) { // change channel num if needed int err; src_delete(src_state_); src_state_ = src_new(SRC_LINEAR, nbChans, &err); format_.nb_channels = nbChans; DEBUG("SRC channel number changed."); } if (nbChans != dataOut.channels()) { DEBUG("Output buffer had the wrong number of channels (in: %d, out: %d).", nbChans, dataOut.channels()); dataOut.setChannelNum(nbChans); } size_t inSamples = nbChans * nbFrames; size_t outSamples = inSamples * sampleFactor; // grow buffer if needed floatBufferIn_.resize(inSamples); floatBufferOut_.resize(outSamples); scratchBuffer_.resize(outSamples); SRC_DATA src_data; src_data.data_in = floatBufferIn_.data(); src_data.data_out = floatBufferOut_.data(); src_data.input_frames = nbFrames; src_data.output_frames = nbFrames * sampleFactor; src_data.src_ratio = sampleFactor; src_data.end_of_input = 0; // More data will come dataIn.interleaveFloat(floatBufferIn_.data()); src_process(src_state_, &src_data); /* TODO: one-shot deinterleave and float-to-short conversion */ src_float_to_short_array(floatBufferOut_.data(), scratchBuffer_.data(), outSamples); dataOut.deinterleave(scratchBuffer_.data(), src_data.output_frames, nbChans); }
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; }
SampleBuffer::handleState::handleState( bool _varying_pitch ) : m_frameIndex( 0 ), m_varyingPitch( _varying_pitch ) { int error; if( ( m_resamplingData = src_new(/* ( engine::mixer()->highQuality() == true ) ? SRC_SINC_FASTEST :*/ SRC_LINEAR, DEFAULT_CHANNELS, &error ) ) == NULL ) { printf( "Error: src_new() failed in sample_buffer.cpp!\n" ); } }
void Resampler::setFormat(AudioFormat format) { format_ = format; samples_ = (format.nb_channels * format.sample_rate * 20) / 1000; // start with 20 ms buffers floatBufferIn_.resize(samples_); floatBufferOut_.resize(samples_); scratchBuffer_.resize(samples_); if (src_state_ != nullptr) src_delete(src_state_); int err; src_state_ = src_new(SRC_LINEAR, format.nb_channels, &err); }
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; }