void Resample()
{
if (m_resample_ctx == null)
{
m_consumer.Consume(m_buffer, m_buffer_offset);
m_buffer_offset = 0;
return;
}
int consumed = 0;
int length = m_resample_ctx.Resample(m_resample_buffer, m_buffer, ref consumed, m_buffer_offset, kMaxBufferSize, true);
if (length > kMaxBufferSize)
{
//DEBUG() << "Chromaprint::AudioProcessor::Resample() -- Resampling overwrote output buffer.\n";
length = kMaxBufferSize;
}
m_consumer.Consume(m_resample_buffer, length);
int remaining = m_buffer_offset - consumed;
if (remaining > 0)
{
Array.Copy(m_buffer, consumed, m_buffer, 0, m_buffer_offset - consumed);
//copy(m_buffer + consumed, m_buffer + m_buffer_offset, m_buffer);
}
else if (remaining < 0)
{
//DEBUG() << "Chromaprint::AudioProcessor::Resample() -- Resampling overread input buffer.\n";
remaining = 0;
}
m_buffer_offset = remaining;
}
public override bool Decode(IAudioConsumer consumer, int maxLength)
{
if (reader == null) return false;
int remaining, length, size;
byte[] buffer = new byte[2 * BUFFER_SIZE];
short[] data = new short[BUFFER_SIZE];
// Samples to read to get maxLength seconds of audio
remaining = maxLength * this.Format.Channels * this.sampleRate;
// Bytes to read
length = 2 * Math.Min(remaining, BUFFER_SIZE);
while ((size = reader.Read(buffer, 0, length)) > 0)
{
Buffer.BlockCopy(buffer, 0, data, 0, size);
consumer.Consume(data, size / 2);
remaining -= size / 2;
if (remaining <= 0)
{
break;
}
length = 2 * Math.Min(remaining, BUFFER_SIZE);
}
return true;
}
public override bool Decode(IAudioConsumer consumer, int maxLength)
{
if (reader == null)
{
return(false);
}
int remaining, length, size;
byte[] buffer = new byte[2 * BUFFER_SIZE];
short[] data = new short[BUFFER_SIZE];
// Samples to read to get maxLength seconds of audio
remaining = maxLength * this.Format.Channels * this.sampleRate;
// Bytes to read
length = 2 * Math.Min(remaining, BUFFER_SIZE);
while ((size = reader.Read(buffer, 0, length)) > 0)
{
Buffer.BlockCopy(buffer, 0, data, 0, size);
consumer.Consume(data, size / 2);
remaining -= size / 2;
if (remaining <= 0)
{
break;
}
length = 2 * Math.Min(remaining, BUFFER_SIZE);
}
return(true);
}
private void Decode(IAudioConsumer consumer, int maxLength)
{
int remaining, length, size;
byte[] buffer = new byte[2 * BUFFER_SIZE];
short[] data = new short[BUFFER_SIZE];
// Samples to read to get maxLength seconds of audio
remaining = maxLength * channels * sampleRate;
// Bytes to read
length = 2 * Math.Min(remaining, BUFFER_SIZE);
while ((size = reader.Read(buffer, 0, length)) > 0)
{
Buffer.BlockCopy(buffer, 0, data, 0, size);
consumer.Consume(data, size / 2);
remaining -= size / 2;
if (remaining <= 0)
{
break;
}
length = 2 * Math.Min(remaining, BUFFER_SIZE);
}
}
public bool Decode(IAudioConsumer consumer, int maxLength)
{
if (_waveSource == null)
{
return(false);
}
if (_buffer == null)
{
_buffer = new byte[BUFFER_SIZE * 2];
}
if (_data == null)
{
_data = new short[BUFFER_SIZE];
}
// maxLength is in seconds of audio
// Calculate maximum bytes to read
var maxBytes = maxLength * Channels * SampleRate;
// Calculate actual bytes we can fit in buffer
var bytesToRead = Math.Min(maxBytes, _buffer.Length);
int read = 0;
while ((read = _waveSource.Read(_buffer, 0, bytesToRead)) > 0)
{
Buffer.BlockCopy(_buffer, 0, _data, 0, read);
consumer.Consume(_data, read / 2);
maxBytes -= read / 2;
if (maxBytes <= 0)
{
break;
}
bytesToRead = Math.Min(maxBytes, _buffer.Length);
}
return(true);
}
public void Consume(short[] input, int length)
{
int offset = 0, n = length;
if (m_start)
{
while (length > 0)
{
m_average.AddValue(Math.Abs(input[offset]));
if (m_average.GetAverage() > m_threshold)
{
m_start = false;
break;
}
offset++;
length--;
}
}
// TODO: workaround pointer magic: shift array data.
if (offset > 0)
{
for (int i = 0; i < n - offset; i++)
{
input[i] = input[i + offset];
}
// Not necessary?
for (int i = n - offset; i < n; i++)
{
input[i] = 0;
}
}
if (length > 0)
{
m_consumer.Consume(input, length);
}
}
/// <summary>
/// Decode an audio file.
/// </summary>
public override bool Decode(IAudioConsumer consumer, int maxLength)
{
if (!ready)
{
return(false);
}
// Get the right stream:
int stream = this.resample ? bassMixer : bassStream;
int remaining, size = 0, length;
short[] data = new short[BUFFER_SIZE];
// Samples to read to get maxLength seconds of audio
remaining = maxLength * this.sampleRate * this.channels;
// Bytes to read
length = 2 * Math.Min(remaining, BUFFER_SIZE);
//while (Bass.BASS_ChannelIsActive(stream) == BASSActive.BASS_ACTIVE_PLAYING)
while (Bass.BASS_ChannelIsActive(stream) == BASSActive.BASS_ACTIVE_PLAYING || size > 0)
{
size = Bass.BASS_ChannelGetData(stream, data, length);
if (size > 0)
{
consumer.Consume(data, size / 2);
remaining -= size / 2;
if (remaining <= 0)
{
break;
}
length = 2 * Math.Min(remaining, BUFFER_SIZE);
}
}
return(true);
}
public bool Decode(IAudioConsumer consumer, int maxLength)
{
if (bitsPerSample != 16)
{
return(false);
}
using (var reader = OpenWaveStream(file))
{
int remaining, length, size;
// TODO: get buffers from memory pool.
byte[] buffer = new byte[2 * BUFFER_SIZE];
short[] data = new short[BUFFER_SIZE];
// Samples to read to get maxLength seconds of audio
remaining = maxLength * Channels * SampleRate;
// Bytes to read
length = 2 * Math.Min(remaining, BUFFER_SIZE);
while ((size = reader.Read(buffer, 0, length)) > 0)
{
Buffer.BlockCopy(buffer, 0, data, 0, size);
consumer.Consume(data, size / 2);
remaining -= size / 2;
if (remaining <= 0)
{
break;
}
length = 2 * Math.Min(remaining, BUFFER_SIZE);
}
return(true);
}
}
