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 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 */
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 void error_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 void simple_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 double find_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 void simple_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; }
void SDLAudioDevice::put_sample(int16_t sample) { lock_guard lock (_mutex); _in.push_back(sample / 32768.f); if (_in.size() > FLUSH_SIZE && _out.available_size() && !_dumping) { _dumping = true; std::thread t0 { [this] { lock_guard lock (_mutex); if (!_out.available_size()) { std::cerr << "No more room in output buffer!\n"; _dumping = false; return; } SRC_DATA data; data.data_in = _in.data(); data.data_out = _out.data() + _out.size(); data.input_frames = _in.size(); data.output_frames = _out.available_size(); data.src_ratio = 44800.0 / 1789773.0; data.end_of_input = 0; int error = src_process(_state, &data); if (error) { std::cerr << "SRC error: " << src_strerror(error) << "\n"; } _in.flush(data.input_frames_used); _out.add(data.output_frames_gen); bool ready = _out.size() > AUDIO_BUFFER_SIZE * 2; if (ready && !_unpaused) { std::cout << "Unpausing audio...\n"; SDL_PauseAudioDevice(_device, 0); _unpaused = true; } _dumping = false; }}; t0.detach(); } }
static bool lsr_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 bool pcm_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 ) ); } }