private static void LoadOgg(VorbisReader vorbis, out byte[] data, out ALFormat format, out uint sampleRate, out TimeSpan len) {
sampleRate = (uint)vorbis.SampleRate;
format = vorbis.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16;
len = vorbis.TotalTime;
float[] buffer = new float[vorbis.SampleRate / 10 * vorbis.Channels];
List<byte> bytes = new List<byte>((int)(vorbis.SampleRate * vorbis.Channels * 2 * len.TotalSeconds));
int count = 0;
while ((count = vorbis.ReadSamples(buffer, 0, buffer.Length)) > 0) {
for (int i = 0; i < count; i++) {
int temp = (int)(short.MaxValue * buffer [i]);
if (temp > short.MaxValue) {
temp = short.MaxValue;
} else if (temp < short.MinValue) {
temp = short.MinValue;
}
short tempBytes = (short)temp;
byte byte1 = (byte)((tempBytes >> 8) & 0x00FF);
byte byte2 = (byte)((tempBytes >> 0) & 0x00FF);
// Little endian
bytes.Add(byte2);
bytes.Add(byte1);
}
}
// TODO: Add better implementation so that there's no need for array copying
data = bytes.ToArray();
}
private static PCMData ReadAll(VorbisReader vorbisStream)
{
PCMData pcm;
pcm.ChannelCount = (short)vorbisStream.Channels;
pcm.SampleRate = vorbisStream.SampleRate;
var samples = new List<float>();
var buffer = new float[DefaultBufferSize];
int samplesRead = 0;
while ((samplesRead = vorbisStream.ReadSamples(buffer, 0, buffer.Length)) > 0)
{
if (samplesRead != buffer.Length)
{
Array.Resize(ref buffer, samplesRead);
}
samples.AddRange(buffer);
buffer = new float[DefaultBufferSize];
}
var samplesArray = samples.ToArray();
pcm.Data = new byte[samplesArray.Length * SampleSizeBytes];
Buffer.BlockCopy(samplesArray, 0, pcm.Data, 0, pcm.Data.Length);
return pcm;
}
/// <summary>
/// Open a <see cref="Stream"/> of sound for reading.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> to open.</param>
/// <param name="ownStream">Specify whether the <see cref="SoundReader"/> should close the source <see cref="Stream"/> upon disposing the reader.</param>
/// <returns>A <see cref="SampleInfo"/> containing sample information.</returns>
public override SampleInfo Open(Stream stream, bool ownStream = false)
{
_reader = new NVorbis.VorbisReader(stream, ownStream);
_channelCount = _reader.Channels;
return new SampleInfo((int)(_reader.TotalSamples * _reader.Channels),
_reader.Channels, _reader.SampleRate);
}
/// <summary>
/// Open a <see cref="Stream"/> of sound for reading.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> to open.</param>
/// <param name="ownStream">Specify whether the <see cref="SoundReader"/> should close the source <see cref="Stream"/> upon disposing the reader.</param>
/// <returns>A <see cref="SampleInfo"/> containing sample information.</returns>
public override SampleInfo Open(Stream stream, bool ownStream = false)
{
_reader = new NVorbis.VorbisReader(stream, ownStream);
_channelCount = _reader.Channels;
return(new SampleInfo((int)(_reader.TotalSamples * _reader.Channels),
_reader.Channels, _reader.SampleRate));
}
public NVorbisSource(Stream stream)
{
if (stream == null)
throw new ArgumentNullException("stream");
if(!stream.CanRead)
throw new ArgumentException("Stream is not readable.", "stream");
_stream = stream;
_vorbisReader = new VorbisReader(stream, false);
_waveFormat = new WaveFormat(_vorbisReader.SampleRate, 32, _vorbisReader.Channels, AudioEncoding.IeeeFloat);
}
public OggSong(string oggFile)
{
reader = new VorbisReader(oggFile);
effect = new DynamicSoundEffectInstance(reader.SampleRate, (AudioChannels)reader.Channels);
buffer = new byte[effect.GetSampleSizeInBytes(TimeSpan.FromMilliseconds(500))];
nvBuffer = new float[buffer.Length / 2];
// when a buffer is needed, set our handle so the helper thread will read in more data
effect.BufferNeeded += (s, e) => readNextBuffer();
}
public AudioClip (string fileName)
{
this.reader = new VorbisReader (fileName);
this.bufferId = AL.GenBuffer ();
float[] buffer = new float[this.Samples * this.Channels];
// ReadSamples could return less data than required for various reasons
int count = this.reader.ReadSamples (buffer, 0, buffer.Length);
AL.BufferData (this.bufferId, this.format, buffer, count * sizeof(float), this.SampleRate);
AudioDevice.CheckError("loading data in OpenAL buffer");
}
private void Dispose(bool manually)
{
if (this.disposed) return;
if (this.ovStream != null)
{
this.ovStream.Dispose();
this.ovStream = null;
}
this.disposed = true;
}
public NVorbisDecoder(Stream stream)
{
//reset the stream
stream.Seek (0, SeekOrigin.Begin);
reader = new VorbisReader (stream, false);
if (reader.Channels == 1) {
format = ALFormat.Mono16;
} else if (reader.Channels == 2) {
format = ALFormat.Stereo16;
} else {
throw new NotSupportedException (string.Format ("{0} channels not supported", reader.Channels));
}
}
public static void SaveVorbisDataToWAV(byte[] vorbisData, string filePath)
{
using (var outStream = new BinaryWriter(new FileStream(filePath, FileMode.Create)))
{
using (var vorbisStream = new VorbisReader(new MemoryStream(vorbisData), true))
{
var pcm = ReadAll(vorbisStream);
WriteRIFFFileHeaderChunk(outStream, pcm);
WriteRIFFFormatChunk(outStream, pcm);
WriteRIFFDataChunk(outStream, pcm);
}
}
}
private SoundEffect LoadOgg(Stream stream)
{
using (var reader = new VorbisReader(stream, false))
{
float[] _buffer = new float[reader.TotalSamples];
byte[] buffer = new byte[reader.TotalSamples * 2];
reader.ReadSamples(_buffer, 0, _buffer.Length);
for (int i = 0; i < _buffer.Length; i++)
{
short val = (short)Math.Max(Math.Min(short.MaxValue * _buffer[i], short.MaxValue), short.MinValue);
var decoded = BitConverter.GetBytes(val);
buffer[i * 2] = decoded[0];
buffer[i * 2 + 1] = decoded[1];
}
return new SoundEffect(buffer, reader.SampleRate, reader.Channels == 1 ? AudioChannels.Mono : AudioChannels.Stereo);
}
}
public OggAudioSource(Stream file, bool streaming = true)
{
Streaming = streaming;
_fileStream = file;
_reader = new VorbisReader(file, false);
_sampleRate = _reader.SampleRate;
_format = (_reader.Channels == 2 ? ALFormat.Stereo16 : ALFormat.Mono16);
if(!Streaming)
{
_data = new short[_reader.TotalSamples];
float[] samples = new float[_reader.TotalSamples];
_reader.ReadSamples(samples, 0, (int)_reader.TotalSamples);
CastSamples(ref samples, ref _data, samples.Length);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="OggReader"/> class.
/// </summary>
public OggReader()
{
_reader = null;
_channelCount = 0;
}
public OggMusicStream(Stream stream)
{
baseStream = stream;
reader = new VorbisReader(stream, false);
}
public override void Reset()
{
_fileStream.Position = 0;
_reader = new VorbisReader(_fileStream, false);
}
internal void Open(bool precache = false)
{
Reader = new VorbisReader(oggFileName);
if (precache)
{
// Fill first buffer synchronously
OggStreamer.Instance.FillBuffer(this, alBufferIds[0]);
AL.SourceQueueBuffer(alSourceId, alBufferIds[0]);
ALHelper.CheckError("Failed to queue buffer.");
}
Ready = true;
}
internal VorbisStreamHandle(string fileName)
{
this.ovStream = new VorbisReader(fileName);
}
public OggFile( Stream stream )
: base()
{
_reader = new VorbisReader( stream, true );
}
VorbisAudioStream(VorbisReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
this.reader = reader;
}
public static void LoadOgg(Stream file, out byte[] data, out ALFormat format, out uint sampleRate, out TimeSpan len) {
using (VorbisReader vorbis = new VorbisReader(file, false)) {
LoadOgg(vorbis, out data, out format, out sampleRate, out len);
}
}
public NVOggPlayer(System.IO.Stream s)
{
reader = new NVorbis.VorbisReader(s, true);
isPlaying = true;
}
public NVOggPlayer(System.IO.Stream s)
{
reader = new NVorbis.VorbisReader(s, true);
isPlaying = true;
}
public static uint BufferFromOgg(Stream file) {
using (VorbisReader vorbis = new VorbisReader(file, false)) {
return BufferFromOgg(vorbis);
}
}
public static uint BufferFromOgg(string file) {
using (VorbisReader vorbis = new VorbisReader(file)) {
return BufferFromOgg(vorbis);
}
}
void loadData()
{
if (filepath != string.Empty && File.Exists(filepath))
{
#if BASS_AUDIO
long trackLengthInBytes = Bass.BASS_ChannelGetLength(handle);
const float FRAME_TIME = 0.002f;
long frameLengthInBytes = Bass.BASS_ChannelSeconds2Bytes(handle, FRAME_TIME);
int NumFrames = (int)System.Math.Round(1f * trackLengthInBytes / frameLengthInBytes);
_data = new float[NumFrames * 2];
float[] levels = new float[2];
for (int i = 0; i < _data.Length && !stop; i += 2)
{
Bass.BASS_ChannelGetLevel(handle, levels, FRAME_TIME, BASSLevel.BASS_LEVEL_STEREO);
float average = (levels[0] + levels[1]) / 2.0f;
_data[i] = -average;
_data[i + 1] = average;
}
#else
byte[] bytes = File.ReadAllBytes(filepath);
float[] sampleData = new float[0];
switch (Path.GetExtension(filepath))
{
case (".ogg"):
NVorbis.VorbisReader vorbis = new NVorbis.VorbisReader(filepath);
vorbis.ClipSamples = false;
_data = new float[vorbis.TotalSamples * vorbis.Channels];
//vorbis.ReadSamples(_data, 0, _data.Length);
int count = 0;
while ((count += vorbis.ReadSamples(_data, count, 16000)) > 0 && !stop)
{
}
break;
case (".wav"):
WAV wav = new WAV(bytes);
sampleData = NAudioPlayer.InterleaveChannels(wav);
break;
case (".mp3"):
NAudioPlayer.WAVFromMp3Data(bytes, out sampleData);
break;
default:
return;
}
#endif
if (!stop)
{
#if !BASS_AUDIO
_data = sampleData;
#endif
Debug.Log("Sample length: " + _data.Length);
}
else
{
_data = new float[0];
}
}
}
internal void Open(bool precache = false)
{
underlyingStream.Seek(0, SeekOrigin.Begin);
Reader = new VorbisReader(underlyingStream, false);
if (precache)
{
// Fill first buffer synchronously
OggStreamer.Instance.FillBuffer(this, alBufferIds[0]);
AL.SourceQueueBuffer(alSourceId, alBufferIds[0]);
ALHelper.Check();
// Schedule the others asynchronously
OggStreamer.Instance.AddStream(this);
}
Ready = true;
}
public void Rewind()
{
baseStream.Position = 0;
reader = new VorbisReader(baseStream, false);
}
/// <summary>
/// Initialize a new instance of <see cref="VorbisAudioSource"/> class with specified file path.
/// </summary>
public VorbisAudioSource(string path)
{
reader = new NVorbis.VorbisReader(path);
}
internal void OpenReader()
{
lastStreamPosition = 0;
CurrentClip.underlyingStream.Seek(lastStreamPosition, SeekOrigin.Begin);
Reader = new VorbisReader(CurrentClip.underlyingStream, false);
}
/// <summary>
/// Initializes a new instance of the <see cref="OggReader"/> class.
/// </summary>
public OggReader()
{
_reader = null;
_channelCount = 0;
}
private void Streamer (object arg)
{
string fileName = (string)arg;
VorbisReader vreader = new VorbisReader (fileName);
// 3 seconds buffering
int bufLen = vreader.Channels * vreader.SampleRate * 3;
float[] buffer = new float[bufLen];
if (this.bufferIds == null) {
this.bufferIds = AL.GenBuffers (3);
AudioDevice.CheckError ("allocating OpenAL buffers for streaming");
}
ALFormat format = vreader.Channels == 2 ? ALFormat.StereoFloat32Ext : ALFormat.MonoFloat32Ext;
// buffer data
int i;
for (i = 0; i < bufferIds.Length; i++) {
int count = vreader.ReadSamples (buffer, 0, bufLen);
// end of the stream ?
if (count == 0) {
if (!this.streamLooping)
break;
vreader.DecodedPosition = 0;
count = vreader.ReadSamples (buffer, 0, bufLen);
}
AL.BufferData<float> (this.bufferIds [i], format, buffer, count * sizeof(float), vreader.SampleRate);
AudioDevice.CheckError ("loading data in OpenAL buffer for streaming");
}
AL.SourceQueueBuffers (this.audioSourceId, i, bufferIds);
AL.SourcePlay (this.audioSourceId);
while (true) {
Thread.Sleep (30);
int processed = 0;
AL.GetSource (this.audioSourceId, ALGetSourcei.BuffersProcessed, out processed);
while (processed > 0) {
int bufferId = AL.SourceUnqueueBuffer (this.audioSourceId);
int count = vreader.ReadSamples (buffer, 0, bufLen);
// end of the straem ?
if (count == 0) {
if (!this.streamLooping) {
this.Stop ();
// to reset status
AL.Source (this.audioSourceId, ALSourcei.Buffer, 0);
return;
}
vreader.DecodedPosition = 0;
count = vreader.ReadSamples (buffer, 0, bufLen);
}
AL.BufferData<float> (bufferId, format, buffer, count * sizeof(float), vreader.SampleRate);
AudioDevice.CheckError ("loading data in OpenAL buffer for streaming");
AL.SourceQueueBuffer (this.audioSourceId, bufferId);
processed--;
}
}
}
internal VorbisStreamHandle(byte[] memory)
{
this.ovStream = new VorbisReader(new MemoryStream(memory), true);
}
public ISoundData Decode(Stream stream)
{
VorbisReader reader = null;
try
{
reader = new VorbisReader (stream, false);
int channels = reader.Channels;
const int BITS_PER_SAMPLE = 16;
int sampleRate = reader.SampleRate;
//Code from: https://github.com/AdamsLair/duality/blob/a911c46b6bc830c05d3bb1202f8e7060543eaefa/Duality/Audio/OggVorbis.cs
List<float[]> allBuffers = new List<float[]>();
bool eof = false;
int totalSamplesRead = 0;
int dataRead = 0;
while (!eof)
{
float[] buffer = new float[DEFAULT_BUFFER_SIZE];
int bufferSamplesRead = 0;
while(bufferSamplesRead < buffer.Length)
{
int samplesRead;
lock (_readMutex)
{
samplesRead = reader.ReadSamples(buffer, dataRead, buffer.Length - dataRead);
}
if (samplesRead > 0)
{
bufferSamplesRead += samplesRead;
}
else
{
eof = true;
break;
}
}
allBuffers.Add(buffer);
totalSamplesRead += bufferSamplesRead;
}
if (totalSamplesRead > 0)
{
short[] data = new short[totalSamplesRead];
int offset = 0;
for (int i = 0; i < allBuffers.Count; i++)
{
int len = Math.Min(totalSamplesRead - offset, allBuffers[i].Length);
castBuffer(allBuffers[i], data, offset, len);
offset += len;
}
return new SoundData(channels, BITS_PER_SAMPLE, sampleRate, data, Marshal.SizeOf(typeof(short)) * data.Length);
}
else
{
Debug.WriteLine("OggDecoder: No samples found in ogg file");
return null;
}
}
catch (InvalidDataException e)
{
Debug.WriteLine("OggDecoder: Failed to read ogg. " + e.ToString());
return null;
}
finally
{
if (reader != null) reader.Dispose();
}
}
private unsafe static uint BufferFromOgg(VorbisReader vorbis) {
uint result;
AL.GenBuffers(1, out result);
byte[] data;
ALFormat format;
uint sampleRate;
TimeSpan len;
LoadOgg(vorbis, out data, out format, out sampleRate, out len);
fixed (byte * dataPtr = &data[0]) {
IntPtr dataIntPtr = new IntPtr(dataPtr);
AL.BufferData(result, format, dataIntPtr, data.Length, (int)sampleRate);
}
return result;
}
internal void Close()
{
if (Reader != null)
{
Reader.Dispose();
Reader = null;
}
Ready = false;
}