void
Resample::cleanup()
{
src_reset(statel);
src_reset(stater);
};
SRC_STATE *
src_new (int converter_type, int channels, int *error)
{ SRC_PRIVATE *psrc ;
if (error)
*error = SRC_ERR_NO_ERROR ;
if (channels < 1)
{ if (error)
*error = SRC_ERR_BAD_CHANNEL_COUNT ;
return NULL ;
} ;
if ((psrc = calloc (1, sizeof (*psrc))) == NULL)
{ if (error)
*error = SRC_ERR_MALLOC_FAILED ;
return NULL ;
} ;
psrc->channels = channels ;
if (sinc_set_converter (psrc, converter_type) != SRC_ERR_NO_ERROR &&
zoh_set_converter (psrc, converter_type) != SRC_ERR_NO_ERROR &&
linear_set_converter (psrc, converter_type) != SRC_ERR_NO_ERROR)
{ if (error)
*error = SRC_ERR_BAD_CONVERTER ;
free (psrc) ;
psrc = NULL ;
} ;
src_reset ((SRC_STATE*) psrc) ;
return (SRC_STATE*) psrc ;
} /* src_new */
static void bufadd (Buffer * b, float * data, int len, double ratio)
{
int oldlen = b->len;
int max = len * ratio + 100;
bufgrow (b, oldlen + max);
SRC_DATA d = {
.data_in = data,
.input_frames = len,
.data_out = OFFSET (b->mem, oldlen),
.output_frames = max,
.src_ratio = ratio};
src_process (srcstate, & d);
b->len = oldlen + d.output_frames_gen;
}
static void speed_flush (void)
{
src_reset (srcstate);
in.len = 0;
out.len = 0;
/* Add silence to the beginning of the input signal. */
bufgrow (& in, width / 2);
trim = width / 2;
written = 0;
ending = FALSE;
}
void AUD_SRCResampleReader::seek(int position)
{
AUD_Specs specs = m_reader->getSpecs();
double factor = double(m_rate) / double(specs.rate);
m_reader->seek(position / factor);
src_reset(m_src);
m_position = position;
}
void Stream::Reset()
{
if(file >= 0) { Disconnect(file); file = -1; }
encoded.Clear();
if(src_state) {
for(int i = 0; i < bufch; ++i) {
src_reset(src_state[i]);
decoded[i].Clear();
}
}
}
bool pass_parse(sourcefile_t *src)
{
const lineelement_t *lelem;
segment_reset();
allBytesResolved = true;
allTermsFinal = true;
dumpPass = false;
/* Set Pet/Screen Mode to the default */
reset_TextMode();
src_reset(src);
if( !pp_init(src) ) {
return false;
}
resetResolveCounter();
while( (lelem=pp_peek())!=NULL && lelem->typ!=LE_EOF )
{
if( !pass_eparse() ) {
pp_skipGarbage();
}
/* Change SegElem if PC was redefined in this line */
segment_processChange();
/* if the number of errors reached the maximum value, stop parsing now */
if( errorcnt>=cfg_maxerrors ) {
printf("maximum number of errors reached. aborting!\n");
break;
}
};
if( errorcnt==0 )
{
if( segment_getPhaseIdx()!=0 ) {
error(EM_PseudoPCStillOpenAtEnd);
return false;
}
if( getLocalBlock()!=0 ) {
error(EM_LocalBlockStillOpenAtEnd);
return false;
}
}
return true;
}
void ResetBuffers()
{
std::lock_guard<std::mutex> lk(mMutex);
pa_sample_spec ss(mSSpec);
ss.rate = mOutputSamplesPerSec;
size_t bytes = pf_pa_bytes_per_second(&mSSpec) * 5;
mQBuffer.resize(0);
mQBuffer.reserve(bytes);
bytes = pf_pa_bytes_per_second(&ss) * 5;
mResampledBuffer.resize(0);
mResampledBuffer.reserve(bytes);
src_reset(mResampler);
}
bool AudioResampler::Seek(size_t offset, Origin origin) {
if (wrapped_decoder->Seek(offset, origin)) {
//reset conversion data
conversion_data.input_frames = 0;
conversion_data.input_frames_used = 0;
finished = wrapped_decoder->IsFinished();
#if defined(HAVE_LIBSPEEXDSP)
speex_resampler_reset_mem(conversion_state);
#elif defined(HAVE_LIBSAMPLERATE)
src_reset(conversion_state);
#endif
return true;
}
return false;
}
bool AudioPlayer::postMessage(OEComponent *sender, int message, void *data)
{
updateAudio(false);
switch (message)
{
case AUDIOPLAYER_PLAY:
playing = true;
break;
case AUDIOPLAYER_PAUSE:
playing = false;
break;
case AUDIOPLAYER_STOP:
frameIndex = 0;
playing = false;
src_reset(srcState);
break;
case AUDIOPLAYER_SET_SOUND:
sound = (OESound *)data;
return true;
case AUDIOPLAYER_SET_LOOP:
loop = *((bool *)data);
return true;
case AUDIOPLAYER_SET_VOLUME:
volume = *((float *)data);
return true;
case AUDIOPLAYER_IS_PLAYING:
*((bool *)data) = playing;
return true;
}
return false;
}
int VarRateResample::Process(double factor,
float *inBuffer,
int inBufferLen,
bool lastFlag,
int *inBufferUsed,
float *outBuffer,
int outBufferLen)
{
src_set_ratio((SRC_STATE *)mHandle, factor);
SRC_DATA data;
if(mShouldReset) {
if(inBufferLen > mSamplesLeft) {
mShouldReset = false;
src_reset((SRC_STATE *)mHandle);
} else {
mSamplesLeft -= inBufferLen;
}
}
data.data_in = inBuffer;
data.data_out = outBuffer;
data.input_frames = inBufferLen;
data.output_frames = outBufferLen;
data.input_frames_used = 0;
data.output_frames_gen = 0;
data.end_of_input = (int)lastFlag;
data.src_ratio = factor;
int err = src_process((SRC_STATE *)mHandle, &data);
if (err) {
wxFprintf(stderr, _("Libsamplerate error: %d\n"), err);
return 0;
}
if(lastFlag) {
mShouldReset = true;
mSamplesLeft = inBufferLen - (int)data.input_frames_used;
}
*inBufferUsed = (int)data.input_frames_used;
return (int)data.output_frames_gen;
}
bool
Deck_playback_process::reset()
{
this->current_sample = 0;
this->remaining_time = 0;
this->stopped = false;
this->paused = false;
for (int i = 0; i < MAX_NB_CUE_POINTS; i++)
{
this->read_cue_point(i);
}
// Reset libsamplerate.
if (this->src_state != nullptr)
{
src_reset(this->src_state);
}
return true;
}
void Resample::reset() {
Algorithm::reset();
_data.end_of_input = 0;
_delay = 0;
// make sure to reset I/O sizes, failure to do this causes inconsitent behavior with libsamplerate
// my theory is that because the signal is being chopped up in different intervals than before,
// the sampling is performed differently
_signal.setAcquireSize(_preferredSize);
_signal.setReleaseSize(_preferredSize);
_resampled.setAcquireSize(_preferredSize);
_resampled.setReleaseSize(_preferredSize);
int maxElementsAtOnce = (int)(_data.src_ratio * _signal.acquireSize()) + 100;
_resampled.setAcquireSize(maxElementsAtOnce);
BufferInfo buf;
buf.size = maxElementsAtOnce * 32;
buf.maxContiguousElements = maxElementsAtOnce*2;
_resampled.setBufferInfo(buf);
int error = src_reset(_state);
if (error) throw EssentiaException("Resample: ", src_strerror(error));
}
static void pcm_src_reset(void *obj)
{
struct rate_src *rate = obj;
src_reset(rate->state);
}
int main(int argc, char **argv)
{
printf("\33[0;40;33m\n");
printf(" FemtoForth Copyright (C) 2014 Victor Yurkovsky\n");
printf(" This program comes with ABSOLUTELY NO WARRANTY'.\n");
printf(" This is free software, and you are welcome to redistribute it\n");
printf(" under certain conditions; type 'license' for details.\n\n");
color(COLOR_RESET);color(FORE_WHITE);
//---------------------------------------------------------------------
// Data segment. Houses var at the bottom...
//
// memmap data segment
U8* data_base = mmap((void*)0x04000000,
CODE_SIZE,
PROT_READ+PROT_WRITE+PROT_EXEC,
MAP_ANONYMOUS|MAP_PRIVATE|MAP_FIXED,
0,0);
//var structure is placed into bottom RESERVED (512) bytes of data!
lay = (sMemLayout*)data_base; // HOST_RESERVED bytes
var = (sVar*)(data_base+HOST_RESERVED); // SYS_RESERVED bytes
// install system var structure at bottom
lay->data_bottom = data_base;
lay->data_top = data_base + CODE_SIZE;
//
var->data_ptr = lay->data_bottom + HOST_RESERVED + SYS_RESERVED;
printf("data at %p->%p ",lay->data_bottom,lay->data_top);
//---------------------------------------------------------------------
// Table - runtime
//
lay->table_bottom = mmap((U8**)(CODE_ADDRESS/4),
sizeof(TINDEX)*TABLE_SIZE,
PROT_READ+PROT_WRITE+PROT_EXEC,
MAP_ANONYMOUS|MAP_SHARED|MAP_FIXED,
0,0);
printf("TABLE at %p ",lay->table_bottom);
lay->table_top = (U8*)lay->table_bottom + sizeof(TINDEX)*TABLE_SIZE;
// var->table_ptr = (U8**)var->table_bottom;
// *var->table_ptr++ = 0 ; //first table entry is always 0 !
//---------------------------------------------------------------------
// DSP
//
//
lay->dsp_bottom = (U8*)malloc(DSP_SIZE);
lay->dsp_top = lay->dsp_bottom + DSP_SIZE;
printf("DSP at %p ",lay->dsp_top);
//---------------------------------------------------------------------
// RSP
lay->rsp_bottom = (U8*)malloc(RSP_SIZE);
lay->rsp_top = lay->rsp_bottom + RSP_SIZE;
var->sp_meow = (sRegsMM*)lay->rsp_top;
printf("RSP at %p ",lay->rsp_top);
//---------------------------------------------------------------------
// HEAD
lay->head_bottom = (U8*)malloc(HEAD_SIZE);
lay->head_top = lay->head_bottom + HEAD_SIZE;
var->head_ptr = lay->head_bottom;
printf("HEAD at %p \n",lay->head_bottom);
//---------------------------------------------------------------------
// SRC
lay->src_bottom = (char*)malloc(256);
src_reset();
head_build();
// printf("data pointer is now at %p\n",var->data_ptr);
kernel_load();
// printf("data pointer is now at %p\n",var->data_ptr);
cmd_init();
lang_init();
// int i;
//for(i=0;i<20;i++)
// U32 qqq = xxx(0x3456,0x1234);
// printf("bindings returns %x\n",1);
interpret_init();
// src_error("ass");
// call_meow();
while(1)
interpret_outer();
// line();
// int z = armFunction(99);
// printf("assembly returnst %d\n",z);
exit(0);
}
float*
mirageaudio_decode(MirageAudio *ma, const gchar *file, int *frames, int* size, int* ret)
{
GstBus *bus;
tic();
ma->fftwsamples = 0;
ma->curhop = 0;
ma->cursample = 0;
ma->quit = FALSE;
g_mutex_lock(ma->decoding_mutex);
ma->invalidate = FALSE;
g_mutex_unlock(ma->decoding_mutex);
// Gstreamer setup
mirageaudio_initgstreamer(ma, file);
if (ma->filerate < 0) {
*size = 0;
*frames = 0;
*ret = -1;
// Gstreamer cleanup
gst_element_set_state(ma->pipeline, GST_STATE_NULL);
gst_object_unref(GST_OBJECT(ma->pipeline));
return NULL;
}
// libsamplerate initialization
ma->src_data.src_ratio = (double)ma->rate/(double)ma->filerate;
ma->src_data.input_frames = 0;
ma->src_data.end_of_input = 0;
src_reset(ma->src_state);
g_print("libmirageaudio: rate=%d, resampling=%f\n", ma->filerate, ma->src_data.src_ratio);
// decode...
gst_element_set_state(ma->pipeline, GST_STATE_PLAYING);
g_print("libmirageaudio: decoding %s\n", file);
bus = gst_pipeline_get_bus(GST_PIPELINE(ma->pipeline));
gboolean decoding = TRUE;
*ret = 0;
while (decoding) {
GstMessage* message = gst_bus_timed_pop_filtered(bus, GST_MSECOND*100,
GST_MESSAGE_ERROR | GST_MESSAGE_EOS);
if (message == NULL)
continue;
switch (GST_MESSAGE_TYPE(message)) {
case GST_MESSAGE_ERROR: {
GError *err;
gchar *debug;
gst_message_parse_error(message, &err, &debug);
g_print("libmirageaudio: error: %s\n", err->message);
g_error_free(err);
g_free(debug);
ma->curhop = 0;
decoding = FALSE;
*ret = -1;
break;
}
case GST_MESSAGE_EOS: {
g_print("libmirageaudio: EOS Message received\n");
decoding = FALSE;
break;
}
default:
break;
}
gst_message_unref(message);
}
gst_object_unref(bus);
g_mutex_lock(ma->decoding_mutex);
// Gstreamer cleanup
gst_element_set_state(ma->pipeline, GST_STATE_NULL);
gst_object_unref(GST_OBJECT(ma->pipeline));
toc();
if (ma->invalidate) {
*size = 0;
*frames = 0;
*ret = -2;
} else {
*size = ma->winsize/2 + 1;
*frames = ma->curhop;
}
g_mutex_unlock(ma->decoding_mutex);
g_print("libmirageaudio: frames=%d (maxhops=%d), size=%d\n", *frames, ma->hops, *size);
return ma->out;
}
void
pcm_resample_lsr_reset(struct pcm_resample_state *state)
{
if (state->state != NULL)
src_reset(state->state);
}
void AUD_SRCResampleReader::seek(int position)
{
m_reader->seek(position / m_factor);
src_reset(m_src);
m_position = position;
}
void TSampleRateAudioStream::Reset()
{
TDecoratedAudioStream::Reset();
src_reset(fResampler);
}
void TaudioFilterResampleSRC::onSeek(void)
{
if (dll->ok) {
src_reset(state);
}
}
HRESULT CSampleRateConverter::FlushStream()
{
HRESULT hr = S_OK;
CAutoLock lock (&m_csOutputSample);
if (m_pNextOutSample)
{
if (FAILED(OutputNextSample()))
{
Log("CSampleRateConverter::FlushStream OutputNextSample failed with: 0x%08x", hr);
return hr;
}
}
LONGLONG framesLeft = (m_llFramesInput * m_dSampleRateRation) - m_llFramesOutput;
if (framesLeft > 0)
{
// SRC allows only one call to "flush" so we use a new sample for the last bits of the stream
if (!m_pNextOutSample && FAILED(hr = RequestNextOutBuffer(m_rtInSampleTime)))
return hr;
long nSize = m_pNextOutSample->GetSize();
BYTE *pOutData = NULL;
if (FAILED(hr = m_pNextOutSample->GetPointer(&pOutData)))
{
Log("CSampleRateConverter: Failed to get output buffer pointer: 0x%08x", hr);
return hr;
}
if (nSize / m_nFrameSize < framesLeft)
Log("CSampleRateConverter: Overflow - Failed to flush SRC data, increase internal sample size!");
BYTE* tmp[1];
SRC_DATA data;
data.data_in = (float*)tmp;
data.data_out = (float*)pOutData;
data.input_frames = 0;
data.output_frames = min(nSize / m_nFrameSize, framesLeft);
data.src_ratio = m_dSampleRateRation;
data.end_of_input = 1;
int srcRet = src_process(m_pSrcState, &data);
if (srcRet == 0 && data.output_frames_gen > 0)
{
ASSERT(data.output_frames_gen == data.output_frames);
m_pNextOutSample->SetActualDataLength(data.output_frames_gen * m_nFrameSize);
UINT nFrames = m_pNextOutSample->GetActualDataLength() / m_pOutputFormat->Format.nBlockAlign;
m_rtInSampleTime += nFrames * UNITS / m_pOutputFormat->Format.nSamplesPerSec;
hr = OutputNextSample();
if (FAILED(hr))
{
Log("CSampleRateConverter::FlushStream OutputNextSample failed with: 0x%08x", hr);
return hr;
}
}
else
m_pNextOutSample.Release();
}
m_llFramesInput = 0;
m_llFramesOutput = 0;
int srcRet = src_reset(m_pSrcState);
if (srcRet != 0)
return S_FALSE;
return hr;
}
// Processing
HRESULT CSampleRateConverter::PutSample(IMediaSample *pSample)
{
if (!pSample)
return S_OK;
AM_MEDIA_TYPE* pmt = NULL;
bool bFormatChanged = false;
HRESULT hr = S_OK;
if (SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt != NULL)
bFormatChanged = !FormatsEqual((WAVEFORMATEXTENSIBLE*)pmt->pbFormat, m_pInputFormat);
if (pSample->IsDiscontinuity() == S_OK)
m_bDiscontinuity = true;
CAutoLock lock (&m_csOutputSample);
if (m_bFlushing)
return S_OK;
if (bFormatChanged)
{
// Process any remaining input
if (!m_bPassThrough)
hr = ProcessData(NULL, 0, NULL);
// Apply format change locally,
// next filter will evaluate the format change when it receives the sample
Log("CSampleRateConverter::PutSample: Processing format change");
ChannelOrder chOrder;
hr = NegotiateFormat((WAVEFORMATEXTENSIBLE*)pmt->pbFormat, 1, &chOrder);
if (FAILED(hr))
{
DeleteMediaType(pmt);
Log("SampleRateConverter: PutSample failed to change format: 0x%08x", hr);
return hr;
}
m_chOrder = chOrder;
}
if (pmt)
DeleteMediaType(pmt);
if (m_bPassThrough)
{
if (m_pNextSink)
return m_pNextSink->PutSample(pSample);
return S_OK; // perhaps we should return S_FALSE to indicate sample was dropped
}
long nOffset = 0;
long cbSampleData = pSample->GetActualDataLength();
BYTE *pData = NULL;
REFERENCE_TIME rtStop = 0;
REFERENCE_TIME rtStart = 0;
pSample->GetTime(&rtStart, &rtStop);
// Detect discontinuity in stream timeline
if ((abs(m_rtNextIncomingSampleTime - rtStart) > MAX_SAMPLE_TIME_ERROR) && m_nSampleNum != 0)
{
Log("CSampleRateConverter - stream discontinuity: %6.3f", (rtStart - m_rtNextIncomingSampleTime) / 10000000.0);
m_rtInSampleTime = rtStart;
if (m_nSampleNum > 0)
{
Log("CSampleRateConverter - using buffered sample data");
FlushStream();
}
else
{
Log("CSampleRateConverter - discarding buffered sample data");
m_llFramesInput = 0;
m_llFramesOutput = 0;
int srcRet = src_reset(m_pSrcState);
if (srcRet != 0)
Log("CSampleRateConverter - src_reset returned error: %d", srcRet);
}
}
if (m_nSampleNum == 0)
m_rtInSampleTime = rtStart;
UINT nFrames = cbSampleData / m_pInputFormat->Format.nBlockAlign;
REFERENCE_TIME duration = nFrames * UNITS / m_pInputFormat->Format.nSamplesPerSec;
m_rtNextIncomingSampleTime = rtStart + duration;
m_nSampleNum++;
hr = pSample->GetPointer(&pData);
ASSERT(pData);
if (FAILED(hr))
{
Log("CSampleRateConverter::PutSample - failed to get sample's data pointer: 0x%08x", hr);
return hr;
}
while (nOffset < cbSampleData && SUCCEEDED(hr))
{
long cbProcessed = 0;
hr = ProcessData(pData+nOffset, cbSampleData - nOffset, &cbProcessed);
nOffset += cbProcessed;
}
return hr;
}
static void
callback_reset_test (int converter)
{ static TEST_CB_DATA test_callback_data ;
static float output [BUFFER_LEN] ;
SRC_STATE *src_state ;
double src_ratio = 1.1 ;
long read_count, read_total ;
int k, error ;
printf ("\tcallback_reset_test (%-28s) ....... ", src_get_name (converter)) ;
fflush (stdout) ;
for (k = 0 ; k < ARRAY_LEN (data_one) ; k++)
{ data_one [k] = 1.0 ;
data_zero [k] = 0.0 ;
} ;
if ((src_state = src_callback_new (test_callback_func, converter, 1, &error, &test_callback_data)) == NULL)
{ printf ("\n\nLine %d : %s\n\n", __LINE__, src_strerror (error)) ;
exit (1) ;
} ;
/* Process a bunch of 1.0 valued samples. */
test_callback_data.channels = 1 ;
test_callback_data.count = 0 ;
test_callback_data.total = ARRAY_LEN (data_one) ;
test_callback_data.data = data_one ;
read_total = 0 ;
do
{ read_count = (ARRAY_LEN (output) - read_total > CB_READ_LEN) ? CB_READ_LEN : ARRAY_LEN (output) - read_total ;
read_count = src_callback_read (src_state, src_ratio, read_count, output + read_total) ;
read_total += read_count ;
}
while (read_count > 0) ;
/* Check for errors. */
if ((error = src_error (src_state)) != 0)
{ printf ("\n\nLine %d : %s\n\n", __LINE__, src_strerror (error)) ;
exit (1) ;
} ;
/* Reset the state of the converter.*/
src_reset (src_state) ;
/* Process a bunch of 0.0 valued samples. */
test_callback_data.channels = 1 ;
test_callback_data.count = 0 ;
test_callback_data.total = ARRAY_LEN (data_zero) ;
test_callback_data.data = data_zero ;
/* Now process some zero data. */
read_total = 0 ;
do
{ read_count = (ARRAY_LEN (output) - read_total > CB_READ_LEN) ? CB_READ_LEN : ARRAY_LEN (output) - read_total ;
read_count = src_callback_read (src_state, src_ratio, read_count, output + read_total) ;
read_total += read_count ;
}
while (read_count > 0) ;
/* Check for errors. */
if ((error = src_error (src_state)) != 0)
{ printf ("\n\nLine %d : %s\n\n", __LINE__, src_strerror (error)) ;
exit (1) ;
} ;
/* Finally make sure that the output data is zero ie reset was sucessful. */
for (k = 0 ; k < BUFFER_LEN / 2 ; k++)
if (output [k] != 0.0)
{ printf ("\n\nLine %d : output [%d] should be 0.0, is %f.\n\n", __LINE__, k, output [k]) ;
save_oct_float ("output.dat", data_one, ARRAY_LEN (data_one), output, ARRAY_LEN (output)) ;
exit (1) ;
} ;
/* Make sure that this function has been exported. */
src_set_ratio (src_state, 1.0) ;
/* Delete converter. */
src_state = src_delete (src_state) ;
puts ("ok") ;
} /* callback_reset_test */
static void
process_reset_test (int converter)
{ static float output [BUFFER_LEN] ;
SRC_STATE *src_state ;
SRC_DATA src_data ;
int k, error ;
printf ("\tprocess_reset_test (%-28s) ....... ", src_get_name (converter)) ;
fflush (stdout) ;
for (k = 0 ; k < BUFFER_LEN ; k++)
{ data_one [k] = 1.0 ;
data_zero [k] = 0.0 ;
} ;
/* Get a converter. */
if ((src_state = src_new (converter, 1, &error)) == NULL)
{ printf ("\n\nLine %d : src_new() failed : %s.\n\n", __LINE__, src_strerror (error)) ;
exit (1) ;
} ;
/* Process a bunch of 1.0 valued samples. */
src_data.data_in = data_one ;
src_data.data_out = output ;
src_data.input_frames = BUFFER_LEN ;
src_data.output_frames = BUFFER_LEN ;
src_data.src_ratio = 0.9 ;
src_data.end_of_input = 1 ;
if ((error = src_process (src_state, &src_data)) != 0)
{ printf ("\n\nLine %d : src_simple () returned error : %s\n\n", __LINE__, src_strerror (error)) ;
exit (1) ;
} ;
/* Reset the state of the converter.*/
src_reset (src_state) ;
/* Now process some zero data. */
src_data.data_in = data_zero ;
src_data.data_out = output ;
src_data.input_frames = BUFFER_LEN ;
src_data.output_frames = BUFFER_LEN ;
src_data.src_ratio = 0.9 ;
src_data.end_of_input = 1 ;
if ((error = src_process (src_state, &src_data)) != 0)
{ printf ("\n\nLine %d : src_simple () returned error : %s\n\n", __LINE__, src_strerror (error)) ;
exit (1) ;
} ;
/* Finally make sure that the output data is zero ie reset was sucessful. */
for (k = 0 ; k < BUFFER_LEN / 2 ; k++)
if (output [k] != 0.0)
{ printf ("\n\nLine %d : output [%d] should be 0.0, is %f.\n", __LINE__, k, output [k]) ;
exit (1) ;
} ;
/* Make sure that this function has been exported. */
src_set_ratio (src_state, 1.0) ;
/* Delete converter. */
src_state = src_delete (src_state) ;
puts ("ok") ;
} /* process_reset_test */
static void op_jack_reset_src(void) {
for (int c = 0; c < CHANNELS; c++) {
src_reset(src_state[c]);
}
}
