What is the proper way of integrating a function in parts using boost odeint? - c++11

Question

I have some code that generates an acoustic timeseries using a 2nd order 1 dimensional differential equation.
I decided to use boost::odeint to integrate the equations, but because this is being used ina real-time simulation, I need to generate a small number of steps repeatedly.
The code is of the following form:
class Integrator
{
public:
typedef std::vector<double> state_type;
//This is how boost::odeint wants it to look
/* NOTE: We have to cast our second order diff eq into a set of first-order diff eqs
because ODEINT only handles first order ODEs.
*/
void operator() ( const state_type &x , state_type &dxdt , const double t )
{
dxdt[0] = x[1];
//... Bunch of calculations here to determine dxdt and ddxdt
dxdt[1] = ddxdtTerm;
}
state_type x_state;
state_type dxdt_state;
std::vector<double> x_buffer;
std::vector<double> time_buffer;
double time;
};
struct IntegrationObserver
{
std::vector<double> & xVals;
std::vector<double> & tVals;
IntegrationObserver(std::vector<double> & in_xVals,
std::vector<double> & in_tVals) :
xVals(in_xVals),
tVals(in_tVals)
{
}
void operator()( const std::vector<double> &x , double t )
{
xVals.push_back( x[0] );
tVals.push_back( t );
}
};
I then have an acoustics generation thread that generates 100ms of acoustic data once every tenth of a second (at 22050 Hz):
std::vector<Integrator> g_intVec;
void audioBufferGeneratorThread()
{
std::cout << "Hello from the audio buffer generator thread!" << std::endl;
Uint32 lastTime = SDL_GetTicks();
Uint32 thisTime = lastTime;
size_t acousticBufsize = 0.1 * 22050;
float* acousticWorkBuffer = new float[acousticBufsize];
memset(acousticWorkBuffer, 0, acousticBufsize * sizeof(float));
while(!g_terminating)
{
bool didWork = false;
//Check time elapsed, have we seen 0.10 seconds pass?
thisTime = SDL_GetTicks();
double t_add = (thisTime - lastTime) / 1000.0;
//For each integrator
if(t_add >= 0.1){
t_add = 0.1;
lastTime = thisTime;
didWork = true;
{
std::lock_guard<std::mutex> guard(g_integratorMutex);
int bubIdx = 0;
for(auto integrator : g_intVec)
{
//Only generate a maximum 1 second of acoustics for each integrator...
//Main thread deletes integrators once they reach
if(integrator.t_sec >= 1.0)
{
continue;
}
size_t steps;
boost::numeric::odeint::runge_kutta4<BubbleIntegrator::state_type> stepper;
//Generate some audio
steps = boost::numeric::odeint::integrate_const(stepper,
integrator,
integrator.x_state,
integrator.t_sec,
integrator.t_sec + t_add,
1.0/22050.,
integratorObserver(integrator.x_buffer, integrator.time_buffer );
integrator.t_sec += t_add;
bubIdx++;
}
//Sum all the audio together
g_integratorMutex.unlock();
}
{
// std::lock_guard<std::mutex> guard(g_audioBufferMutex);
//Push the audio to the audio buffer
}
memset(acousticWorkBuffer, 0, acousticBufsize * sizeof(float));
}
//Yield the thread if we didn't generate any acoustics.
else
{
std::this_thread::yield();
}
}
delete acousticWorkBuffer;
std::cout << "Goodbye from the audio buffer generator thread..." << std::endl;
}
As one can see, this code is meant to store the previous X and DXDT states, as well as the current time, so that the integrator can pick up where it left off later.
However, the problem appears to be that the integrator is calculating from t=0 every time, so each advance through the acoustics generator loop takes longer and longer until the code is no longer able to generate the acoustics in realtime (i.e. generate 100ms of acoustics in under 100ms of code time).
It appears that I'm using the odeint library incorrectly, but I am unable to find a proper example of how to do what I'm trying to do here: generate the first 100ms of data, then the next 100ms, then the next, etc...
So my question is thus:
How can I use boost::odeint to generate sequential chunks of the equation without it starting from t=0 each time?