Streaming improved.
delete[] m_y;
}
-void AUD_BaseIIRFilterReader::read(int & length, sample_t* buffer)
+void AUD_BaseIIRFilterReader::read(int& length, bool& eos, sample_t* buffer)
{
- m_reader->read(length, buffer);
+ m_reader->read(length, eos, buffer);
for(m_channel = 0; m_channel < m_channels; m_channel++)
{
virtual ~AUD_BaseIIRFilterReader();
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
virtual sample_t filter()=0;
};
return m_reader->getPosition() + m_delay;
}
-void AUD_DelayReader::read(int & length, sample_t* buffer)
+void AUD_DelayReader::read(int& length, bool& eos, sample_t* buffer)
{
if(m_remdelay > 0)
{
memset(buffer, 0, m_remdelay * samplesize);
int len = length - m_remdelay;
- m_reader->read(len, buffer + m_remdelay * specs.channels);
+ m_reader->read(len, eos, buffer + m_remdelay * specs.channels);
- if(len < length-m_remdelay)
- length = m_remdelay + len;
+ length = m_remdelay + len;
m_remdelay = 0;
}
}
}
else
- m_reader->read(length, buffer);
+ m_reader->read(length, eos, buffer);
}
virtual void seek(int position);
virtual int getLength() const;
virtual int getPosition() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_DELAYREADER
return m_reader1->getSpecs();
}
-void AUD_DoubleReader::read(int & length, sample_t* buffer)
+void AUD_DoubleReader::read(int& length, bool& eos, sample_t* buffer)
{
if(!m_finished1)
{
int len = length;
- m_reader1->read(len, buffer);
+ m_reader1->read(len, m_finished1, buffer);
- if(len < length)
+ if(m_finished1)
{
const AUD_Specs specs = m_reader1->getSpecs();
len = length - len;
length -= len;
- m_reader2->read(len, buffer + length * specs.channels);
+ m_reader2->read(len, eos, buffer + length * specs.channels);
length += len;
-
- m_finished1 = true;
}
}
else
{
- m_reader2->read(length, buffer);
+ m_reader2->read(length, eos, buffer);
}
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_DOUBLEREADER
return m_reader->getSpecs();
}
-void AUD_EffectReader::read(int & length, sample_t* buffer)
+void AUD_EffectReader::read(int& length, bool& eos, sample_t* buffer)
{
- m_reader->read(length, buffer);
+ m_reader->read(length, eos, buffer);
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_EFFECTREADER
{
}
-void AUD_FaderReader::read(int & length, sample_t* buffer)
+void AUD_FaderReader::read(int& length, bool& eos, sample_t* buffer)
{
int position = m_reader->getPosition();
AUD_Specs specs = m_reader->getSpecs();
int samplesize = AUD_SAMPLE_SIZE(specs);
- m_reader->read(length, buffer);
+ m_reader->read(length, eos, buffer);
if((position + length) / (float)specs.rate <= m_start)
{
AUD_FaderReader(AUD_Reference<AUD_IReader> reader, AUD_FadeType type,
float start,float length);
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_FADERREADER
// skip first m_start samples by reading them
int length = AUD_DEFAULT_BUFFER_SIZE;
AUD_Buffer buffer(AUD_DEFAULT_BUFFER_SIZE * AUD_SAMPLE_SIZE(m_reader->getSpecs()));
+ bool eos = false;
for(int len = m_start;
- length == AUD_DEFAULT_BUFFER_SIZE;
+ length == AUD_DEFAULT_BUFFER_SIZE && !eos;
len -= AUD_DEFAULT_BUFFER_SIZE)
{
if(len < AUD_DEFAULT_BUFFER_SIZE)
length = len;
- m_reader->read(length, buffer.getBuffer());
+
+ m_reader->read(length, eos, buffer.getBuffer());
}
}
}
return AUD_MIN(pos, m_end) - m_start;
}
-void AUD_LimiterReader::read(int & length, sample_t* buffer)
+void AUD_LimiterReader::read(int& length, bool& eos, sample_t* buffer)
{
+ eos = false;
if(m_end >= 0)
{
int position = m_reader->getPosition();
if(position + length > m_end)
+ {
length = m_end - position;
+ eos = true;
+ }
+
+ if(position < m_start)
+ {
+ int len2 = length;
+ for(int len = m_start - position;
+ len2 == length && !eos;
+ len -= length)
+ {
+ if(len < length)
+ len2 = len;
+
+ m_reader->read(len2, eos, buffer);
+ position += len2;
+ }
+
+ if(position < m_start)
+ {
+ length = 0;
+ return;
+ }
+ }
+
if(length < 0)
{
length = 0;
return;
}
}
- m_reader->read(length, buffer);
+ if(eos)
+ {
+ m_reader->read(length, eos, buffer);
+ eos = true;
+ }
+ else
+ m_reader->read(length, eos, buffer);
}
virtual void seek(int position);
virtual int getLength() const;
virtual int getPosition() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_LIMITERREADER
return m_reader->getPosition() * (m_count < 0 ? 1 : m_count);
}
-void AUD_LoopReader::read(int & length, sample_t* buffer)
+void AUD_LoopReader::read(int& length, bool& eos, sample_t* buffer)
{
- AUD_Specs specs = m_reader->getSpecs();
+ const AUD_Specs specs = m_reader->getSpecs();
int len = length;
- m_reader->read(len, buffer);
+ m_reader->read(length, eos, buffer);
- if(len < length && m_left)
+ if(length < len && eos && m_left)
{
- int pos = 0;
-
- pos += len;
+ int pos = length;
+ length = len;
- while(pos < length && m_left)
+ while(pos < length && eos && m_left)
{
if(m_left > 0)
m_left--;
m_reader->seek(0);
len = length - pos;
- m_reader->read(len, buffer + pos * specs.channels);
+ m_reader->read(len, eos, buffer + pos * specs.channels);
// prevent endless loop
if(!len)
length = pos;
}
- else
- length = len;
}
virtual void seek(int position);
virtual int getLength() const;
virtual int getPosition() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_LOOPREADER
return m_position;
}
-void AUD_ReverseReader::read(int & length, sample_t* buffer)
+void AUD_ReverseReader::read(int& length, bool& eos, sample_t* buffer)
{
// first correct the length
if(m_position + length > m_length)
if(length <= 0)
{
length = 0;
+ eos = true;
return;
}
// read from reader
m_reader->seek(m_length - m_position - len);
- m_reader->read(len, buffer);
+ m_reader->read(len, eos, buffer);
// set null if reader didn't give enough data
if(len < length)
}
m_position += length;
+ eos = false;
}
virtual void seek(int position);
virtual int getLength() const;
virtual int getPosition() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_REVERSEREADER
return m_reader1->getSpecs();
}
-void AUD_SuperposeReader::read(int & length, sample_t* buffer)
+void AUD_SuperposeReader::read(int& length, bool& eos, sample_t* buffer)
{
AUD_Specs specs = m_reader1->getSpecs();
int samplesize = AUD_SAMPLE_SIZE(specs);
m_buffer.assureSize(length * samplesize);
int len1 = length;
- m_reader1->read(len1, buffer);
+ m_reader1->read(len1, eos, buffer);
if(len1 < length)
memset(buffer + len1 * specs.channels, 0, (length - len1) * samplesize);
int len2 = length;
+ bool eos2;
sample_t* buf = m_buffer.getBuffer();
- m_reader2->read(len2, buf);
+ m_reader2->read(len2, eos2, buf);
for(int i = 0; i < len2 * specs.channels; i++)
buffer[i] += buf[i];
length = AUD_MAX(len1, len2);
+ eos &= eos2;
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_SUPERPOSEREADER
int current;
/// Whether the stream doesn't return any more data.
- bool data_end;
+ bool eos;
/// The loop count of the source.
int loopcount;
while(info--)
{
// if there's still data to play back
- if(!sound->data_end)
+ if(!sound->eos)
{
// read data
length = m_buffersize;
- sound->reader->read(length, m_buffer.getBuffer());
+ sound->reader->read(length, sound->eos, m_buffer.getBuffer());
// looping necessary?
if(length == 0 && sound->loopcount)
sound->reader->seek(0);
length = m_buffersize;
- sound->reader->read(length, m_buffer.getBuffer());
+ sound->reader->read(length, sound->eos, m_buffer.getBuffer());
}
+ if(sound->loopcount != 0)
+ sound->eos = false;
+
// read nothing?
if(length == 0)
{
- sound->data_end = true;
break;
}
ALenum err;
if((err = alGetError()) != AL_NO_ERROR)
{
- sound->data_end = true;
+ sound->eos = true;
break;
}
if((err = alGetError()) != AL_NO_ERROR)
{
- sound->data_end = true;
+ sound->eos = true;
break;
}
&sound->buffers[sound->current]);
if(alGetError() != AL_NO_ERROR)
{
- sound->data_end = true;
+ sound->eos = true;
break;
}
if(info != AL_PLAYING)
{
// if it really stopped
- if(sound->data_end)
+ if(sound->eos)
{
if(sound->stop)
sound->stop(sound->stop_data);
sound->reader = reader;
sound->current = 0;
sound->isBuffered = false;
- sound->data_end = false;
sound->loopcount = 0;
sound->stop = NULL;
sound->stop_data = NULL;
for(int i = 0; i < AUD_OPENAL_CYCLE_BUFFERS; i++)
{
length = m_buffersize;
- reader->read(length, m_buffer.getBuffer());
+ reader->read(length,sound->eos, m_buffer.getBuffer());
alBufferData(sound->buffers[i], sound->format, m_buffer.getBuffer(),
length * AUD_DEVICE_SAMPLE_SIZE(specs),
specs.rate);
sound->keep = keep;
sound->current = -1;
sound->isBuffered = true;
- sound->data_end = true;
+ sound->eos = true;
sound->loopcount = 0;
sound->stop = NULL;
sound->stop_data = NULL;
{
alhandle->reader->seek((int)(position *
alhandle->reader->getSpecs().rate));
- alhandle->data_end = false;
+ alhandle->eos = false;
ALint info;
for(int i = 0; i < AUD_OPENAL_CYCLE_BUFFERS; i++)
{
length = m_buffersize;
- alhandle->reader->read(length, m_buffer.getBuffer());
+ alhandle->reader->read(length, alhandle->eos, m_buffer.getBuffer());
alBufferData(alhandle->buffers[i], alhandle->format,
m_buffer.getBuffer(),
length * AUD_DEVICE_SAMPLE_SIZE(specs),
break;
}
+ if(alhandle->loopcount != 0)
+ alhandle->eos = false;
+
alSourceQueueBuffers(alhandle->source,
AUD_OPENAL_CYCLE_BUFFERS,
alhandle->buffers);
lock();
bool result = isValid(handle);
if(result)
+ {
((AUD_OpenALHandle*)handle)->loopcount = count;
+ ((AUD_OpenALHandle*)handle)->eos = false;
+ }
unlock();
return result;
}
int length = m_buffer.getSize() / AUD_SAMPLE_SIZE(m_tspecs);
*data = m_buffer.getBuffer();
- m_reader->read(length, *data);
+ m_reader->read(length, m_eos, *data);
return length;
}
return m_tspecs;
}
-void AUD_SRCResampleReader::read(int & length, sample_t* buffer)
+void AUD_SRCResampleReader::read(int& length, bool& eos, sample_t* buffer)
{
- int size = length * AUD_SAMPLE_SIZE(m_tspecs);
+ int size = length;
- m_buffer.assureSize(size);
+ m_buffer.assureSize(length * AUD_SAMPLE_SIZE(m_tspecs));
+
+ m_eos = false;
length = src_callback_read(m_src, m_factor, length, buffer);
m_position += length;
+
+ eos = m_eos && (length < size);
}
*/
int m_position;
+ /**
+ * Whether reader reached end of stream.
+ */
+ bool m_eos;
+
// hide copy constructor and operator=
AUD_SRCResampleReader(const AUD_SRCResampleReader&);
AUD_SRCResampleReader& operator=(const AUD_SRCResampleReader&);
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_SRCRESAMPLEREADER
// read until we're at the right position
int length = AUD_DEFAULT_BUFFER_SIZE;
AUD_Buffer buffer(length * AUD_SAMPLE_SIZE(m_specs));
+ bool eos;
for(int len = position - m_position;
length == AUD_DEFAULT_BUFFER_SIZE;
len -= AUD_DEFAULT_BUFFER_SIZE)
{
if(len < AUD_DEFAULT_BUFFER_SIZE)
length = len;
- read(length, buffer.getBuffer());
+ read(length, eos, buffer.getBuffer());
}
}
}
return m_specs.specs;
}
-void AUD_FFMPEGReader::read(int & length, sample_t* buffer)
+void AUD_FFMPEGReader::read(int& length, bool& eos, sample_t* buffer)
{
// read packages and decode them
AVPacket packet;
pkgbuf_pos-data_size);
}
- if(left > 0)
+ if(eos = (left > 0))
length -= left;
+
m_position += length;
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_FFMPEGREADER
return m_specs;
}
-void AUD_BufferReader::read(int & length, sample_t* buffer)
+void AUD_BufferReader::read(int& length, bool& eos, sample_t* buffer)
{
int sample_size = AUD_SAMPLE_SIZE(m_specs);
// in case the end of the buffer is reached
if(m_buffer->getSize() < (m_position + length) * sample_size)
+ {
length = m_buffer->getSize() / sample_size - m_position;
+ eos = true;
+ }
if(length < 0)
{
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_BUFFERREADER
int len;
int position = 0;
+ bool eos;
do
{
len = samplerate;
buffer.resize((position + len) * sizeof(float), true);
- reader->read(len, buffer.getBuffer() + position);
+ reader->read(len, eos, buffer.getBuffer() + position);
position += len;
- } while(len != 0);
+ } while(!eos);
float* result = (float*)malloc(position * sizeof(float));
memcpy(result, buffer.getBuffer(), position * sizeof(float));
int len = reader->getLength();
float samplejump = (float)len / (float)length;
float min, max;
+ bool eos;
for(int i = 0; i < length; i++)
{
buf = aBuffer.getBuffer();
}
- reader->read(len, buf);
+ reader->read(len, eos, buf);
- if(len < 1)
+ if(eos)
{
length = i;
break;
return m_specs;
}
-void AUD_ChannelMapperReader::read(int & length, sample_t* buffer)
+void AUD_ChannelMapperReader::read(int& length, bool& eos, sample_t* buffer)
{
m_buffer.assureSize(length * m_rch * sizeof(sample_t));
sample_t* in = m_buffer.getBuffer();
- m_reader->read(length, in);
+ m_reader->read(length, eos, in);
sample_t sum;
~AUD_ChannelMapperReader();
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_CHANNELMAPPERREADER
return m_specs.specs;
}
-void AUD_ConverterReader::read(int & length, sample_t* buffer)
+void AUD_ConverterReader::read(int& length, bool& eos, sample_t* buffer)
{
int samplesize = AUD_SAMPLE_SIZE(m_reader->getSpecs());
m_buffer.assureSize(length * samplesize);
- m_reader->read(length, m_buffer.getBuffer());
+ m_reader->read(length, eos, m_buffer.getBuffer());
m_convert((data_t*)buffer, (data_t*)m_buffer.getBuffer(),
length * m_specs.channels);
AUD_ConverterReader(AUD_Reference<AUD_IReader> reader, AUD_DeviceSpecs specs);
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_CONVERTERREADER
/**
* Request to read the next length samples out of the source.
- * The buffer for reading has to stay valid until the next call of this
- * method or until the reader is deleted.
+ * The buffer supplied has the needed size.
* \param[in,out] length The count of samples that should be read. Shall
* contain the real count of samples after reading, in case
* there were only fewer samples available.
* A smaller value also indicates the end of the reader.
- * \param[out] buffer The pointer to the buffer with the samples.
+ * \param[out] eos End of stream, whether the end is reached or not.
+ * \param[int] buffer The pointer to the buffer to read into.
*/
- virtual void read(int & length, sample_t* buffer)=0;
+ virtual void read(int& length, bool& eos, sample_t* buffer)=0;
};
#endif //AUD_IREADER
return m_tspecs;
}
-void AUD_LinearResampleReader::read(int & length, sample_t* buffer)
+void AUD_LinearResampleReader::read(int& length, bool& eos, sample_t* buffer)
{
int samplesize = AUD_SAMPLE_SIZE(m_tspecs);
- int size = length * AUD_SAMPLE_SIZE(m_sspecs);
+ int size = length;
- m_buffer.assureSize(size);
+ m_buffer.assureSize(size * AUD_SAMPLE_SIZE(m_sspecs));
int need = ceil((m_position + length) / m_factor) + 1 - m_sposition;
int len = need;
sample_t* buf = m_buffer.getBuffer();
- m_reader->read(len, buf);
+ m_reader->read(len, eos, buf);
if(len < need)
length = floor((m_sposition + len - 1) * m_factor) - m_position;
m_sposition += len;
m_position += length;
+ eos &= length < size;
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_LINEARRESAMPLEREADER
return m_mixer->getSpecs().specs;
}
-void AUD_SequencerReader::read(int & length, sample_t* buffer)
+void AUD_SequencerReader::read(int& length, bool& eos, sample_t* buffer)
{
AUD_DeviceSpecs specs = m_mixer->getSpecs();
int rate = specs.rate;
len -= skip;
if(strip->reader->getPosition() != current)
strip->reader->seek(current);
- strip->reader->read(len, m_buffer.getBuffer());
+ strip->reader->read(len, eos, m_buffer.getBuffer());
m_mixer->mix(m_buffer.getBuffer(), skip, len, m_volume(m_data, strip->entry->data, (float)m_position / (float)rate));
}
}
m_mixer->read((data_t*)buffer, 1.0f);
m_position += length;
+
+ eos = false;
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_SEQUENCERREADER
return specs;
}
-void AUD_SilenceReader::read(int & length, sample_t* buffer)
+void AUD_SilenceReader::read(int& length, bool& eos, sample_t* buffer)
{
memset(buffer, 0, length * sizeof(sample_t));
m_position += length;
+ eos = false;
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_SILENCEREADER
return specs;
}
-void AUD_SinusReader::read(int & length, sample_t* buffer)
+void AUD_SinusReader::read(int& length, bool& eos, sample_t* buffer)
{
// fill with sine data
for(int i = 0; i < length; i++)
}
m_position += length;
+ eos = false;
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_SINUSREADER
AUD_SoftwareHandle* sound;
int len;
int pos;
+ bool eos;
std::list<AUD_SoftwareHandle*> stopSounds;
sample_t* buf = m_buffer.getBuffer();
pos = 0;
len = length;
- sound->reader->read(len, buf);
+ sound->reader->read(len, eos, buf);
// in case of looping
- while(pos + len < length && sound->loopcount)
+ while(pos + len < length && sound->loopcount && eos)
{
m_mixer->mix(buf, pos, len, sound->volume);
sound->reader->seek(0);
len = length - pos;
- sound->reader->read(len, buf);
+ sound->reader->read(len, eos, buf);
// prevent endless loop
if(!len)
pos += len;
// in case the end of the sound is reached
- if(pos < length)
+ if(eos && !sound->loopcount)
{
if(sound->stop)
sound->stop(sound->stop_data);
int sample_size = AUD_SAMPLE_SIZE(m_specs);
int length;
int index = 0;
+ bool eos = false;
// get an approximated size if possible
int size = reader->getLength();
else
size += m_specs.rate;
- // as long as we fill our buffer to the end
- while(index == m_buffer->getSize() / sample_size)
+ // as long as the end of the stream is not reached
+ while(!eos)
{
// increase
m_buffer->resize(size*sample_size, true);
// read more
length = size-index;
- reader->read(length, m_buffer->getBuffer() + index * m_specs.channels);
- size += AUD_BUFFER_RESIZE_BYTES / sample_size;
+ reader->read(length, eos, m_buffer->getBuffer() + index * m_specs.channels);
+ if(index == m_buffer->getSize() / sample_size)
+ size += AUD_BUFFER_RESIZE_BYTES / sample_size;
index += length;
}
return m_specs;
}
-void AUD_SndFileReader::read(int & length, sample_t* buffer)
+void AUD_SndFileReader::read(int& length, bool& eos, sample_t* buffer)
{
+ int olen = length;
+
length = sf_readf_float(m_sndfile, buffer, length);
m_position += length;
+
+ eos = length < olen;
}
virtual int getLength() const;
virtual int getPosition() const;
virtual AUD_Specs getSpecs() const;
- virtual void read(int & length, sample_t* buffer);
+ virtual void read(int& length, bool& eos, sample_t* buffer);
};
#endif //AUD_SNDFILEREADER