/// <summary>
/// Decodes the ogg-vorbis file
/// </summary>
/// <param name="input">Stream of the ogg-vorbis file</param>
/// <returns>PCM-Wave version of the input</returns>
public WaveFile Decode(Stream input)
{
MemoryStream output = new MemoryStream();
WaveFile wf = new WaveFile();
VorbisFile vf = new VorbisFile((FileStream)input, null, 0);
Info inf = vf.getInfo(-1);
wf.Channels = (short)inf.channels;
wf.Frequency = inf.rate;
wf.Bits = 16;
Axiom.Core.LogManager.Instance.Write("SoundSystem: File is Ogg Vorbis "+inf.version.ToString()+" "+inf.rate.ToString()+"Hz, "+inf.channels.ToString()+" channels");
int bufferlen = 4096;
int result = 1;
byte[] buffer = new byte[bufferlen];
int[] section = new int[1];
while(result != 0)
{
result = vf.read(buffer, bufferlen, 0, 2, 1, section);
output.Write(buffer, 0, result);
}
output.Seek(0, SeekOrigin.Begin);
wf.Data = output;
return wf;
}
/// <summary>Constructor - Supports opening an Ogg Vorbis file</summary>
public OggVorbisFileReader(string oggFileName)
{
m_vorbisFile = new VorbisFile(oggFileName);
Info[] info = m_vorbisFile.getInfo();
// TODO: 8 bit is hard coded!! need to figure out how to calculate it, Ogg tags do not seem to contain it
int bitsPerSample = 8;
m_waveFormat = new WaveFormat(info[0].rate, bitsPerSample, info[0].channels);
}
/// <summary>Supports opening an Ogg Vorbis file</summary>
public OggFileReader(string oggFileName)
{
m_vorbisFile = new VorbisFile(oggFileName);
info = m_vorbisFile.getInfo();
// TODO: 8 is hard coded!! need to change it dynamically by reading tags
waveFormat = new WaveFormat(info[0].rate, 8, info[0].channels);
pcm_total = m_vorbisFile.pcm_total(-1);
timeSpan = m_vorbisFile.time_total(-1); // Timespan in seconds
}
private TagLib.File m_TagLibFile; // TagLibSharp file object
#endregion Fields
#region Constructors
/// <summary>
/// Constructor
/// </summary>
/// <param name="Filename">
/// A <see cref="System.String"/> containing the path to the Ogg Vorbis file this instance represents
/// </param>
public OggFile(string Filename)
{
// Check that the file exists
if (!(System.IO.File.Exists(Filename))) { throw new OggFileReadException("File not found", Filename); }
// Load the relevant objects
m_Filename = Filename;
try
{
m_CSVorbisFile = new VorbisFile(m_Filename);
}
catch (Exception ex)
{
throw new OggFileReadException("Unable to open file for data reading\n" + ex.Message, Filename);
}
try
{
m_TagLibFile = TagLib.File.Create(m_Filename);
}
catch (TagLib.UnsupportedFormatException ex)
{
throw new OggFileReadException("Unsupported format (not an ogg?)\n" + ex.Message, Filename);
}
catch (TagLib.CorruptFileException ex)
{
throw new OggFileCorruptException(ex.Message, Filename, "Tags");
}
// Populate some other info shizzle and do a little bit of sanity checking
m_Streams = m_CSVorbisFile.streams();
if (m_Streams<=0) { throw new OggFileReadException("File doesn't contain any logical bitstreams", Filename); }
// Assuming <0 is for whole file and >=0 is for specific logical bitstreams
m_Bitrate = m_CSVorbisFile.bitrate(-1);
m_LengthTime = (int)m_CSVorbisFile.time_total(-1);
// Figure out the ALFormat of the stream
m_Info = m_CSVorbisFile.getInfo(); // Get the info of the first stream, assuming all streams are the same? Dunno if this is safe tbh
if (m_Info[0] == null) { throw new OggFileReadException("Unable to determine Format{FileInfo.Channels} for first bitstream", Filename); }
if (m_TagLibFile.Properties.AudioBitrate==16) {
m_Format = (m_Info[0].channels)==1 ? ALFormat.Mono16 : ALFormat.Stereo16; // This looks like a fudge, but I've seen it a couple of times (what about the other formats I wonder?)
}
else
{
m_Format = (m_Info[0].channels)==1 ? ALFormat.Mono8 : ALFormat.Stereo8;
}
// A grab our first instance of the file so we're ready to play
m_CSVorbisFileInstance = m_CSVorbisFile.makeInstance();
}
public VorbisFileInstance(VorbisFile sourceFile)
{
vorbisFile = sourceFile;
oy = new SyncState();
bittrack = 0;
samptrack = 0;
os = new StreamState(); // take physical pages, weld into a logical
// stream of packets
vd = new DspState(); // central working state for
// the packet->PCM decoder
vb = new Block(vd); // local working space for packet->PCM decode
raw_seek(0);
lastStreamPosition = sourceFile.datasource.Position;
}
public void Dispose()
{
m_TagLibFile.Dispose();
m_TagLibFile = null;
m_CSVorbisFile.Dispose();
m_CSVorbisFile = null;
}
/// <summary>
/// Reset the OggFile (reload from disk).
/// Useful if tags have changed externally, or to reset the internal position pointer to replay the file from the beginning
/// SeekToTime(0) is the prefered method of moving the internal pointer to the beginning however however
/// </summary>
public void ResetFile()
{
try
{
m_CSVorbisFile = null;
m_CSVorbisFile = new VorbisFile(m_Filename); // No point reloading anything else 'cos it shouldn't have changed
m_TagLibFile = null;
m_TagLibFile = TagLib.File.Create(m_Filename);
}
catch (Exception ex)
{
throw new Exception("Unable to reload OggFile [" + m_Filename + "]", ex);
}
}
/// <summary>
/// Disposes this WaveStream
/// </summary>
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (m_vorbisFile != null)
{
m_vorbisFile.Dispose();
m_vorbisFile = null;
}
}
base.Dispose(disposing);
}
public AudioFile(Stream inputStream)
{
sourceAudio = new VorbisFile(inputStream);
RemoveDelay(64 * 1024);
}
public AudioFile(string fileName)
{
sourceAudio = new VorbisFile(fileName);
RemoveDelay(64 * 1024);
}
public void LoadOGG(SoundType sound)
{
// Dirty way of checking that we have ogg-dlls in exe path....
if (!File.Exists("csogg.dll") || !File.Exists("csvorbis.dll"))
{
return; // return 0;
}
int ab = sound.Buffer;
//#define ogg // or activate this, but this is just for this place/file... :D
#if noogg
#warning "Returning 0 on Ogg file, you need to define \"ogg\" in build constants, in project build property."
return ; // quicker upstart
#endif
VorbisFile asd = new VorbisFile(sound.Filename);
System.Diagnostics.Debug.WriteLine(sound.Filename);
Info info = asd.getInfo(-1);
//long samples = asd.pcm_total(-1);
//int streams = asd.streams();
//byte[] data3 = new byte[samples*streams];
byte[] data2 = new byte[4096];
Stream output2 = new MemoryStream();
int readBytes = 0;
while ((readBytes = asd.read(data2, data2.Length, 0 /*Bigendian*/, /*(info.rate < 44100 ? 2 : 2)*/ 2 /*1=byte, 2=16bit*/, 1/*signd*/, null)) > 0)
{
output2.Write(data2, 0, readBytes);
}
data2 = null;
data2 = new byte[output2.Length];
output2.Seek(0, SeekOrigin.Begin);
output2.Read(data2, 0, data2.Length);
output2.Close();
//output2.Dispose();
output2 = null;
//
#region csogg and stuff, commented
// borrow from csogg and csvorbis...
/*using (var input = new FileStream(filename, FileMode.Open, FileAccess.Read))
{
System.Diagnostics.Debug.WriteLine(filename);
bool skipWavHeader = true;
int HEADER_SIZE = 36;
int convsize = 4096 * 2;
byte[] convbuffer = new byte[convsize]; // take 8k out of the data segment, not the stack
Stream output = new MemoryStream();
if (!skipWavHeader)
output.Seek(HEADER_SIZE, SeekOrigin.Begin); // reserve place for WAV header
SyncState oy = new SyncState(); // sync and verify incoming physical bitstream
StreamState os = new StreamState(); // take physical pages, weld into a logical stream of packets
Page og = new Page(); // one Ogg bitstream page. Vorbis packets are inside
Packet op = new Packet(); // one raw packet of data for decode
Info vi = new Info(); // struct that stores all the static vorbis bitstream settings
Comment vc = new Comment(); // struct that stores all the bitstream user comments
DspState vd = new DspState(); // central working state for the packet->PCM decoder
Block vb = new Block(vd); // local working space for packet->PCM decode
byte[] buffer;
int bytes = 0;
// Decode setup
oy.init(); // Now we can read pages
while (true)
{ // we repeat if the bitstream is chained
int eos = 0;
// grab some data at the head of the stream. We want the first page
// (which is guaranteed to be small and only contain the Vorbis
// stream initial header) We need the first page to get the stream
// serialno.
// submit a 4k block to libvorbis' Ogg layer
int index = oy.buffer(4096);
buffer = oy.data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
}
oy.wrote(bytes);
// Get the first page.
if (oy.pageout(og) != 1)
{
// have we simply run out of data? If so, we're done.
if (bytes < 4096) break;
// error case. Must not be Vorbis data
System.Diagnostics.Debug.WriteLine("Input does not appear to be an Ogg bitstream.");
}
// Get the serial number and set up the rest of decode.
// serialno first; use it to set up a logical stream
os.init(og.serialno());
// extract the initial header from the first page and verify that the
// Ogg bitstream is in fact Vorbis data
// I handle the initial header first instead of just having the code
// read all three Vorbis headers at once because reading the initial
// header is an easy way to identify a Vorbis bitstream and it's
// useful to see that functionality seperated out.
vi.init();
vc.init();
if (os.pagein(og) < 0)
{
// error; stream version mismatch perhaps
System.Diagnostics.Debug.WriteLine("Error reading first page of Ogg bitstream data.");
}
if (os.packetout(op) != 1)
{
// no page? must not be vorbis
System.Diagnostics.Debug.WriteLine("Error reading initial header packet.");
}
if (vi.synthesis_headerin(vc, op) < 0)
{
// error case; not a vorbis header
System.Diagnostics.Debug.WriteLine("This Ogg bitstream does not contain Vorbis audio data.");
}
// At this point, we're sure we're Vorbis. We've set up the logical
// (Ogg) bitstream decoder. Get the comment and codebook headers and
// set up the Vorbis decoder
// The next two packets in order are the comment and codebook headers.
// They're likely large and may span multiple pages. Thus we reead
// and submit data until we get our two pacakets, watching that no
// pages are missing. If a page is missing, error out; losing a
// header page is the only place where missing data is fatal.
int i = 0;
while (i < 2)
{
while (i < 2)
{
int result = oy.pageout(og);
if (result == 0) break; // Need more data
// Don't complain about missing or corrupt data yet. We'll
// catch it at the packet output phase
if (result == 1)
{
os.pagein(og); // we can ignore any errors here
// as they'll also become apparent
// at packetout
while (i < 2)
{
result = os.packetout(op);
if (result == 0) break;
if (result == -1)
{
// Uh oh; data at some point was corrupted or missing!
// We can't tolerate that in a header. Die.
System.Diagnostics.Debug.WriteLine("Corrupt secondary header. Exiting.");
}
vi.synthesis_headerin(vc, op);
i++;
}
}
}
// no harm in not checking before adding more
index = oy.buffer(4096);
buffer = oy.data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
}
if (bytes == 0 && i < 2)
{
System.Diagnostics.Debug.WriteLine("End of file before finding all Vorbis headers!");
}
oy.wrote(bytes);
}
// Throw the comments plus a few lines about the bitstream we're decoding
{
byte[][] ptr = vc.user_comments;
for (int j = 0; j < vc.user_comments.Length; j++)
{
if (ptr[j] == null) break;
System.Diagnostics.Debug.WriteLine(vc.getComment(j));
}
System.Diagnostics.Debug.WriteLine("\nBitstream is " + vi.channels + " channel, " + vi.rate + "Hz");
System.Diagnostics.Debug.WriteLine("Encoded by: " + vc.getVendor() + "\n");
} // comment this on release...
convsize = 4096 / vi.channels;
// OK, got and parsed all three headers. Initialize the Vorbis
// packet->PCM decoder.
vd.synthesis_init(vi); // central decode state
vb.init(vd); // local state for most of the decode
// so multiple block decodes can
// proceed in parallel. We could init
// multiple vorbis_block structures
// for vd here
float[][][] _pcm = new float[1][][];
int[] _index = new int[vi.channels];
// The rest is just a straight decode loop until end of stream
while (eos == 0)
{
while (eos == 0)
{
int result = oy.pageout(og);
if (result == 0) break; // need more data
if (result == -1)
{ // missing or corrupt data at this page position
System.Diagnostics.Debug.WriteLine("Corrupt or missing data in bitstream; continuing...");
}
else
{
os.pagein(og); // can safely ignore errors at
// this point
while (true)
{
result = os.packetout(op);
if (result == 0) break; // need more data
if (result == -1)
{ // missing or corrupt data at this page position
// no reason to complain; already complained above
}
else
{
// we have a packet. Decode it
int samples;
if (vb.synthesis(op) == 0)
{ // test for success!
vd.synthesis_blockin(vb);
}
// **pcm is a multichannel float vector. In stereo, for
// example, pcm[0] is left, and pcm[1] is right. samples is
// the size of each channel. Convert the float values
// (-1.<=range<=1.) to whatever PCM format and write it out
while ((samples = vd.synthesis_pcmout(_pcm, _index)) > 0)
{
float[][] pcm = _pcm[0];
bool clipflag = false;
int bout = (samples < convsize ? samples : convsize);
// convert floats to 16 bit signed ints (host order) and
// interleave
for (i = 0; i < vi.channels; i++)
{
int ptr = i * 2;
//int ptr=i;
int mono = _index[i];
for (int j = 0; j < bout; j++)
{
int val = (int)(pcm[i][mono + j] * 32767.0);
// short val=(short)(pcm[i][mono+j]*32767.);
// int val=(int)Math.round(pcm[i][mono+j]*32767.);
// might as well guard against clipping
if (val > 32767)
{
val = 32767;
clipflag = true;
}
if (val < -32768)
{
val = -32768;
clipflag = true;
}
if (val < 0) val = val | 0x8000;
convbuffer[ptr] = (byte)(val);
convbuffer[ptr + 1] = (byte)((uint)val >> 8);
ptr += 2 * (vi.channels);
}
}
if (clipflag)
{
//s_err.WriteLine("Clipping in frame "+vd.sequence);
}
output.Write(convbuffer, 0, 2 * vi.channels * bout);
vd.synthesis_read(bout); // tell libvorbis how
// many samples we
// actually consumed
}
}
}
if (og.eos() != 0) eos = 1;
}
}
if (eos == 0)
{
index = oy.buffer(4096);
buffer = oy.data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
}
oy.wrote(bytes);
if (bytes == 0) eos = 1;
}
}
// clean up this logical bitstream; before exit we see if we're
// followed by another [chained]
os.clear();
// ogg_page and ogg_packet structs always point to storage in
// libvorbis. They're never freed or manipulated directly
vb.clear();
vd.clear();
vi.clear(); // must be called last
}
// OK, clean up the framer
oy.clear();
System.Diagnostics.Debug.WriteLine("Done.");
output.Seek(0, SeekOrigin.Begin);
if (!skipWavHeader)
{
WriteHeader(output, (int)(output.Length - HEADER_SIZE), vi.rate, (ushort)16, (ushort)vi.channels);
output.Seek(0, SeekOrigin.Begin);
}
*/
#endregion
//
ALFormat alf = 0;
if (/*vi*/info.channels == 1) // mono
{
alf = ALFormat.Mono16;
}
else if (/*vi*/info.channels == 2) // sterio
{
alf = ALFormat.Stereo16;
}
else if (alf == 0)
{
throw new Exception("Wrong number of channels in sound file.");
}
/*BinaryReader bw = new BinaryReader(output);
byte[] data = bw.ReadBytes((int)output.Length);
bw.Close();
bw.Dispose();*/
/*byte[] data = new byte[(int)output.Length];
output.Read(data, 0, data.Length);
output.Close();
output.Dispose();*/
AL.BufferData(ab, alf, data2, data2.Length, /*vi.rate*/ info.rate);
//data = null;
//}
//return ab;
}
/// <summary>
/// Dispose method
/// </summary>
/// <param name="disposing">Is it disposing?</param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
// free managed resources
if (BufferID >= 0) //???
{
AL.DeleteBuffer(BufferID);
}
FileToBuffer = null;
FileInfoVO.clear();
FileInfoVO = null;
}
// free native resources if there are any.
disposed = true;
System.Diagnostics.Debug.WriteLine(this.GetType().ToString() + " disposed.");
}
}
/// <summary>
/// Constructor for SoundType class
/// </summary>
/// <param name="FileName">String of the filepath</param>
/// <param name="IsToBeStreaming">Is it to be streamed?</param>
public SoundType(string FileName, bool IsToBeStreaming)
{
if (!System.IO.File.Exists(FileName))
{
throw new Exception("Missing sound file!");
}
File = FileName;
Streaming = IsToBeStreaming;
if (!Streaming)
{
BufferID = AL.GenBuffer();
}
else
{
BufferID = -1;
}
// This makes the program take some time to load...
FileToBuffer = new VorbisFile(File);
FileInfoVO = FileToBuffer.getInfo(-1);
alf = 0;
/*int asd = FileToBuffer.bitrate(-1);
int asd2 = FileToBuffer.bitrate_instant();*/
if (FileInfoVO.channels == 1) // mono
{
alf = ALFormat.Mono16;
}
else if (FileInfoVO.channels == 2) // sterio
{
alf = ALFormat.Stereo16;
}
else if (alf == 0)
{
throw new Exception("Wrong number of channels in sound file.");
}
}
/// <summary>
/// Reads an audio clip from the given stream.
/// </summary>
/// <param name="inputStream">The stream to read from.</param>
public AudioClip(Stream inputStream)
{
rawClip = new VorbisFile(inputStream);
Cache(64 * 1024);
}
/// <summary>
/// Constructs an audio clip from the given file.
/// </summary>
/// <param name="fileName">The file which to read from.</param>
public AudioClip(string fileName)
{
rawClip = new VorbisFile(fileName);
Cache(64 * 1024);
}