void AUD_SoftwareDevice::mix(data_t* buffer, int length)
{
m_buffer.assureSize(length * AUD_SAMPLE_SIZE(m_specs));
lock();
{
AUD_Reference<AUD_SoftwareDevice::AUD_SoftwareHandle> sound;
int len;
int pos;
bool eos;
std::list<AUD_Reference<AUD_SoftwareDevice::AUD_SoftwareHandle> > stopSounds;
std::list<AUD_Reference<AUD_SoftwareDevice::AUD_SoftwareHandle> > pauseSounds;
sample_t* buf = m_buffer.getBuffer();
m_mixer->clear(length);
// for all sounds
AUD_HandleIterator it = m_playingSounds.begin();
while(it != m_playingSounds.end())
{
sound = *it;
// increment the iterator to make sure it's valid,
// in case the sound gets deleted after stopping
++it;
// get the buffer from the source
pos = 0;
len = length;
// update 3D Info
sound->update();
sound->m_reader->read(len, eos, buf);
// in case of looping
while(pos + len < length && sound->m_loopcount && eos)
{
m_mixer->mix(buf, pos, len, sound->m_volume);
pos += len;
if(sound->m_loopcount > 0)
sound->m_loopcount--;
sound->m_reader->seek(0);
len = length - pos;
sound->m_reader->read(len, eos, buf);
// prevent endless loop
if(!len)
break;
}
m_mixer->mix(buf, pos, len, sound->m_volume);
// in case the end of the sound is reached
if(eos && !sound->m_loopcount)
{
if(sound->m_stop)
sound->m_stop(sound->m_stop_data);
if(sound->m_keep)
pauseSounds.push_back(sound);
else
stopSounds.push_back(sound);
}
}
// superpose
m_mixer->read(buffer, m_volume);
// cleanup
while(!stopSounds.empty())
{
sound = stopSounds.front();
stopSounds.pop_front();
sound->stop();
}
while(!pauseSounds.empty())
{
sound = pauseSounds.front();
pauseSounds.pop_front();
sound->pause();
}
}
unlock();
}
void AUD_SequencerReader::read(int& length, bool& eos, sample_t* buffer)
{
m_factory->lock();
if(m_factory->m_status != m_status)
{
m_device.changeSpecs(m_factory->m_specs);
m_device.setSpeedOfSound(m_factory->m_speed_of_sound);
m_device.setDistanceModel(m_factory->m_distance_model);
m_device.setDopplerFactor(m_factory->m_doppler_factor);
m_status = m_factory->m_status;
}
if(m_factory->m_entry_status != m_entry_status)
{
std::list<AUD_Reference<AUD_SequencerHandle> > handles;
AUD_HandleIterator hit = m_handles.begin();
AUD_EntryIterator eit = m_factory->m_entries.begin();
int result;
AUD_Reference<AUD_SequencerHandle> handle;
while(hit != m_handles.end() && eit != m_factory->m_entries.end())
{
handle = *hit;
AUD_Reference<AUD_SequencerEntry> entry = *eit;
result = handle->compare(entry);
if(result < 0)
{
handle = new AUD_SequencerHandle(entry, m_device);
handles.push_front(handle);
eit++;
}
else if(result == 0)
{
handles.push_back(handle);
hit++;
eit++;
}
else
{
handle->stop();
hit++;
}
}
while(hit != m_handles.end())
{
(*hit)->stop();
hit++;
}
while(eit != m_factory->m_entries.end())
{
handle = new AUD_SequencerHandle(*eit, m_device);
handles.push_front(handle);
eit++;
}
m_handles = handles;
m_entry_status = m_factory->m_entry_status;
}
AUD_Specs specs = m_factory->m_specs;
int pos = 0;
float time = float(m_position) / float(specs.rate);
float volume, frame;
int len, cfra;
AUD_Vector3 v, v2;
AUD_Quaternion q;
while(pos < length)
{
frame = time * m_factory->m_fps;
cfra = int(floor(frame));
len = int(ceil((cfra + 1) / m_factory->m_fps * specs.rate)) - m_position;
len = AUD_MIN(length - pos, len);
len = AUD_MAX(len, 1);
for(AUD_HandleIterator it = m_handles.begin(); it != m_handles.end(); it++)
{
(*it)->update(time, frame);
}
m_factory->m_volume.read(frame, &volume);
m_device.setVolume(volume);
m_factory->m_orientation.read(frame, q.get());
m_device.setListenerOrientation(q);
m_factory->m_location.read(frame, v.get());
m_device.setListenerLocation(v);
m_factory->m_location.read(frame + 1, v2.get());
v2 -= v;
m_device.setListenerVelocity(v2);
m_device.read(reinterpret_cast<data_t*>(buffer + specs.channels * pos), len);
pos += len;
time += float(len) / float(specs.rate);
}
m_factory->unlock();
m_position += length;
eos = false;
}
