/// <summary>
/// packet where to put the packet
/// </summary>
/// <param name="packet"></param>
/// <returns></returns>
private int GetNextPacket(Packet packet)
{
// get next packet.
bool fetchedPacket = false;
while (!EndOfStream && !fetchedPacket)
{
int result1 = StreamState.packetout(packet);
if (result1 == 0)
{
// no more packets in page. Fetch new page.
int result2 = 0;
while (!EndOfStream && result2 == 0)
{
result2 = SyncState.pageout(Page);
if (result2 == 0)
{
FetchData();
}
}
// return if we have reaced end of file.
if ((result2 == 0) && (Page.eos() != 0))
{
return(-1);
}
if (result2 == 0)
{
// need more data fetching page..
FetchData();
}
else if (result2 == -1)
{
//throw new Exception("syncState.pageout(page) result == -1");
Console.WriteLine("syncState.pageout(page) result == -1");
return(-1);
}
else
{
int result3 = StreamState.pagein(Page);
}
}
else if (result1 == -1)
{
//throw new Exception("streamState.packetout(packet) result == -1");
Console.WriteLine("streamState.packetout(packet) result == -1");
return(-1);
}
else
{
fetchedPacket = true;
}
}
return(0);
}
Stream DecodeStream(Stream input, bool skipWavHeader)
{
int convsize = 4096 * 2;
byte[] convbuffer = new byte[convsize]; // take 8k out of the data segment, not the stack
TextWriter s_err = new DebugWriter();
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)
{
s_err.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
s_err.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
s_err.WriteLine("Error reading first page of Ogg bitstream data.");
}
if (os.packetout(op) != 1)
{
// no page? must not be vorbis
s_err.WriteLine("Error reading initial header packet.");
}
if (vi.synthesis_headerin(vc, op) < 0)
{
// error case; not a vorbis header
s_err.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.
s_err.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)
{
s_err.WriteLine(e);
}
if (bytes == 0 && i < 2)
{
s_err.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;
}
s_err.WriteLine(vc.getComment(j));
}
s_err.WriteLine("\nBitstream is " + vi.channels + " channel, " + vi.rate + "Hz");
s_err.WriteLine("Encoded by: " + vc.getVendor() + "\n");
}
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
s_err.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)
{
s_err.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();
s_err.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);
}
return(output);
}
static byte[] convbuffer = new byte[convsize]; // take 8k out of the data segment, not the stack
#endregion Fields
#region Methods
public static void main(String[] arg)
{
//Stream output = File.OpenWrite("output.bin");
var Name = "Output.ogg";
var OutputBuffer = new MemoryStream();
Stream input = null;
//java.io.InputStream input=System.In;
if (arg.Length > 0)
{
try
{
Name = arg[0];
input = File.OpenRead(arg[0]);
}
catch (Exception e)
{
Console.Error.WriteLine(e);
}
}
else
{
throw (new NotImplementedException("aaaa"));
}
if (input == null) throw (new NotImplementedException("bbb"));
var SyncState = new SyncState(); // sync and verify incoming physical bitstream
var StreamState = new StreamState(); // take physical pages, weld into a logical stream of packets
var Page = new Page(); // one Ogg bitstream page. Vorbis packets are inside
var Packet = new Packet(); // one raw packet of data for decode
var Info = new Info(); // struct that stores all the static vorbis bitstream settings
var Comment = new Comment(); // struct that stores all the bitstream user comments
var DspState = new DspState(); // central working state for the packet->PCM decoder
var Block = new Block(DspState); // local working space for packet->PCM decode
byte[] buffer;
int bytes = 0;
// Decode setup
SyncState.Init(); // Now we can read pages
// we repeat if the bitstream is chained
while (true)
{
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 = SyncState.Buffer(4096);
buffer = SyncState.Data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
Console.Error.WriteLine(e);
return;
}
SyncState.wrote(bytes);
// Get the first page.
int _result = SyncState.PageOut(Page);
if (_result != 1)
{
// have we simply run out of data? If so, we're done.
if (bytes < 4096) break;
Console.WriteLine(bytes + "; " + _result);
//File.WriteAllBytes();
// error case. Must not be Vorbis data
Console.Error.WriteLine("Input does not appear to be an Ogg bitstream.");
return;
}
// Get the serial number and set up the rest of decode.
// serialno first; use it to set up a logical stream
StreamState.Init(Page.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.
Info.init();
Comment.init();
if (StreamState.pagein(Page) < 0)
{
// error; stream version mismatch perhaps
throw (new Exception("Error reading first page of Ogg bitstream data."));
}
if (StreamState.PacketOut(Packet) != 1)
{
// no page? must not be vorbis
throw (new Exception("Error reading initial header packet."));
}
if (Info.synthesis_headerin(Comment, Packet) < 0)
{
// error case; not a vorbis header
throw (new Exception("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 = SyncState.PageOut(Page);
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)
{
StreamState.pagein(Page); // we can ignore any errors here
// as they'll also become apparent
// at packetout
while (i < 2)
{
result = StreamState.PacketOut(Packet);
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.
throw(new Exception("Corrupt secondary header. Exiting."));
}
Info.synthesis_headerin(Comment, Packet);
i++;
}
}
}
// no harm in not checking before adding more
index = SyncState.Buffer(4096);
buffer = SyncState.Data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
throw(new Exception("Exception", e));
}
if (bytes == 0 && i < 2)
{
throw(new Exception("End of file before finding all Vorbis headers!"));
}
SyncState.wrote(bytes);
}
// Throw the comments plus a few lines about the bitstream we're
// decoding
{
byte[][] ptr = Comment.user_comments;
for (int j = 0; j < ptr.Length; j++)
{
if (ptr[j] == null)
break;
Console.Error.WriteLine(Util.InternalEncoding.GetString(ptr[j], 0, ptr[j].Length - 1));
}
Console.Error.WriteLine("\nBitstream is {0} channel, {1}Hz", Info.channels, Info.rate);
Console.Error.WriteLine(
"Encoded by: {0}\n",
Util.InternalEncoding.GetString(Comment.vendor, 0, Comment.vendor.Length - 1));
}
convsize = 4096 / Info.channels;
// OK, got and parsed all three headers. Initialize the Vorbis
// packet->PCM decoder.
DspState.synthesis_init(Info); // central decode state
Block.init(DspState); // 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[Info.channels];
// The rest is just a straight decode loop until end of stream
while (eos == 0)
{
while (eos == 0)
{
int result = SyncState.PageOut(Page);
if (result == 0)
break; // need more data
if (result == -1)
{ // missing or corrupt data at this page position
Console.Error.WriteLine("Corrupt or missing data in bitstream; continuing...");
}
else
{
StreamState.pagein(Page); // can safely ignore errors at
// this point
while (true)
{
result = StreamState.PacketOut(Packet);
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 (Block.synthesis(Packet) == 0)
{ // test for success!
DspState.synthesis_blockin(Block);
}
// **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 = DspState.synthesis_pcmout(_pcm, _index)) > 0)
{
float[][] pcm = _pcm[0];
int bout = (samples < convsize ? samples : convsize);
// convert floats to 16 bit signed ints (host order) and
// interleave
for (i = 0; i < Info.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;
}
if (val < -32768)
{
val = -32768;
}
if (val < 0)
val = val | 0x8000;
convbuffer[ptr] = (byte)(val);
convbuffer[ptr + 1] = (byte)(((uint)val) >> 8);
ptr += 2 * (Info.channels);
}
}
// System.out.write(convbuffer, 0, 2*vi.channels*bout);
//throw(new NotImplementedException("ccccccccc"));
OutputBuffer.Write(convbuffer, 0, 2 * Info.channels * bout);
// tell libvorbis how
// many samples we
// actually consumed
DspState.synthesis_read(bout);
}
}
}
if (Page.eos() != 0)
eos = 1;
}
}
if (eos == 0)
{
index = SyncState.Buffer(4096);
buffer = SyncState.Data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
throw(new Exception("Exception", e));
}
SyncState.wrote(bytes);
if (bytes == 0) eos = 1;
}
}
// clean up this logical bitstream; before exit we see if we're
// followed by another [chained]
StreamState.Clear();
// ogg_page and ogg_packet structs always point to storage in
// libvorbis. They're never freed or manipulated directly
Block.clear();
DspState.clear();
Info.Clear(); // must be called last
}
// OK, clean up the framer
SyncState.Clear();
var WaveStream = new WaveStream();
using (var WaveOutputStream = File.OpenWrite(Name + ".wav"))
{
OutputBuffer.Position = 0;
WaveStream.WriteWave(WaveOutputStream, () =>
{
OutputBuffer.CopyTo(WaveOutputStream);
}, NumberOfChannels: 1, SampleRate: 44100);
}
Console.Error.WriteLine("Done.");
}
/// <summary>
/// Initalizes the vorbis stream. Reads the stream until info and comment are read.
/// </summary>
private void InitVorbis()
{
// Now we can read pages
SyncState.init();
// 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 = SyncState.buffer(4096);
byte[] buffer = SyncState.data;
int bytes = Stream.Read(buffer, 0, buffer.Length);
SyncState.wrote(bytes);
// Get the first page.
if (SyncState.pageout(Page) != 1)
{
// have we simply run out of data? If so, we're done.
if (bytes < 4096)
{
return; //break;
}
// error case. Must not be Vorbis data
throw new Exception("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
StreamState.init(Page.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.
Info.init();
Comment.init();
if (StreamState.pagein(Page) < 0)
{
// error; stream version mismatch perhaps
throw new Exception("Error reading first page of Ogg bitstream data.");
}
if (StreamState.packetout(Packet) != 1)
{
// no page? must not be vorbis
throw new Exception("Error reading initial header packet.");
}
if (Info.synthesis_headerin(Comment, Packet) < 0)
{
// error case; not a vorbis header
throw new Exception("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 read
// and submit data until we get our two packets, 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 = SyncState.pageout(Page);
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)
{
StreamState.pagein(Page); // we can ignore any errors here
// as they'll also become apparent
// at packetout
while (i < 2)
{
result = StreamState.packetout(Packet);
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.
throw new Exception("Corrupt secondary header. Exiting.");
}
Info.synthesis_headerin(Comment, Packet);
i++;
}
}
}
// no harm in not checking before adding more
index = SyncState.buffer(4096);
buffer = SyncState.data;
bytes = Stream.Read(buffer, index, 4096);
// NOTE: This is a bugfix. read will return -1 which will mess up syncState.
if (bytes < 0)
{
bytes = 0;
}
if (bytes == 0 && i < 2)
{
throw new Exception("End of file before finding all Vorbis headers!");
}
SyncState.wrote(bytes);
}
convsize = 4096 / Info.channels;
// OK, got and parsed all three headers. Initialize the Vorbis
// packet->PCM decoder.
dspState.synthesis_init(Info); // central decode state
Block.init(dspState); // 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
}
public AudioSample OggToWav(Stream ogg, float volume, float pitch)
{
AudioSample sample = new AudioSample();
TextWriter s_err = new StringWriter();
Stream input = null;
MemoryStream output = null;
input = ogg;
output = new MemoryStream();
SyncState oy = new SyncState();
StreamState os = new StreamState();
Page og = new Page();
Packet op = new Packet();
Info vi = new Info();
Comment vc = new Comment();
DspState vd = new DspState();
Block vb = new Block(vd);
byte[] buffer;
int bytes = 0;
oy.init();
while (true)
{
int eos = 0;
int index = oy.buffer(4096);
buffer = oy.data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
s_err.WriteLine(e);
}
oy.wrote(bytes);
if (oy.pageout(og) != 1)
{
if (bytes < 4096)
{
break;
}
s_err.WriteLine("Input does not appear to be an Ogg bitstream.");
}
os.init(og.serialno());
vi.init();
vc.init();
if (os.pagein(og) < 0)
{
s_err.WriteLine("Error reading first page of Ogg bitstream data.");
}
if (os.packetout(op) != 1)
{
s_err.WriteLine("Error reading initial header packet.");
}
if (vi.synthesis_headerin(vc, op) < 0)
{
s_err.WriteLine("This Ogg bitstream does not contain Vorbis audio data.");
}
int i = 0;
while (i < 2)
{
while (i < 2)
{
int result = oy.pageout(og);
if (result == 0)
{
break;
}
if (result == 1)
{
os.pagein(og);
while (i < 2)
{
result = os.packetout(op);
if (result == 0)
{
break;
}
vi.synthesis_headerin(vc, op);
i++;
}
}
}
index = oy.buffer(4096);
buffer = oy.data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
s_err.WriteLine(e);
}
oy.wrote(bytes);
}
sample.Channels = vi.channels;
sample.Rate = (int)((float)vi.rate * pitch);
convsize = 4096 / vi.channels;
vd.synthesis_init(vi);
vb.init(vd);
float[][][] _pcm = new float[1][][];
int[] _index = new int[vi.channels];
while (eos == 0)
{
while (eos == 0)
{
int result = oy.pageout(og);
if (result == 0)
{
break;
}
if (result != -1)
{
os.pagein(og);
while (true)
{
result = os.packetout(op);
if (result == 0)
{
break;
}
if (result != -1)
{
int samples;
if (vb.synthesis(op) == 0)
{
vd.synthesis_blockin(vb);
}
while ((samples = vd.synthesis_pcmout(_pcm, _index)) > 0)
{
float[][] pcm = _pcm[0];
int bout = (samples < convsize ? samples : convsize);
for (i = 0; i < vi.channels; i++)
{
int ptr = i * 2;
int mono = _index[i];
for (int j = 0; j < bout; j++)
{
int val = (int)(pcm[i][mono + j] * 32767.0);
if (val > 32767)
{
val = 32767;
}
if (val < -32768)
{
val = -32768;
}
val = (int)((float)val * volume);
if (val < 0)
{
val = val | 0x8000;
}
convbuffer[ptr] = (byte)(val);
convbuffer[ptr + 1] = (byte)((uint)val >> 8);
ptr += 2 * (vi.channels);
}
}
output.Write(convbuffer, 0, 2 * vi.channels * bout);
vd.synthesis_read(bout);
}
}
}
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)
{
s_err.WriteLine(e);
}
oy.wrote(bytes);
if (bytes == 0)
{
eos = 1;
}
}
}
os.clear();
vb.clear();
vd.clear();
vi.clear();
break;
}
oy.clear();
input.Close();
sample.Pcm = output.ToArray();
return(sample);
}
// uses the local ogg_stream storage in vf; this is important for
// non-streaming input sources
int fetch_headers(Info vi, Comment vc, int[] serialno, Page og_ptr)
{
//System.err.println("fetch_headers");
Page og=new Page();
Packet op=new Packet();
int ret;
if(og_ptr==null)
{
ret=get_next_page(og, CHUNKSIZE);
if(ret==OV_EREAD)return OV_EREAD;
if(ret<0) return OV_ENOTVORBIS;
og_ptr=og;
}
if(serialno!=null)serialno[0]=og_ptr.serialno();
os.init(og_ptr.serialno());
// extract the initial header from the first page and verify that the
// Ogg bitstream is in fact Vorbis data
vi.init();
vc.init();
int i=0;
while(i<3)
{
os.pagein(og_ptr);
while(i<3)
{
int result=os.packetout(op);
if(result==0)break;
if(result==-1)
{
Console.Error.WriteLine("Corrupt header in logical bitstream.");
//goto bail_header;
vi.clear();
vc.clear();
os.clear();
return -1;
}
if(vi.synthesis_headerin(vc, op)!=0)
{
Console.Error.WriteLine("Illegal header in logical bitstream.");
//goto bail_header;
vi.clear();
vc.clear();
os.clear();
return -1;
}
i++;
}
if(i<3)
if(get_next_page(og_ptr, 1)<0)
{
Console.Error.WriteLine("Missing header in logical bitstream.");
//goto bail_header;
vi.clear();
vc.clear();
os.clear();
return -1;
}
}
return 0;
}
// fetch and process a packet. Handles the case where we're at a
// bitstream boundary and dumps the decoding machine. If the decoding
// machine is unloaded, it loads it. It also keeps pcm_offset up to
// date (seek and read both use this. seek uses a special hack with
// readp).
//
// return: -1) hole in the data (lost packet)
// 0) need more date (only if readp==0)/eof
// 1) got a packet
int process_packet(int readp)
{
Page og = new Page();
// handle one packet. Try to fetch it from current stream state
// extract packets from page
while (true)
{
// process a packet if we can. If the machine isn't loaded,
// neither is a page
if (decode_ready)
{
Packet op = new Packet();
int result = os.packetout(op);
long granulepos;
// if(result==-1)return(-1); // hole in the data. For now, swallow
// and go. We'll need to add a real
// error code in a bit.
if (result > 0)
{
// got a packet. process it
granulepos = op.granulepos;
if (vb.synthesis(op) == 0)
{ // lazy check for lazy
// header handling. The
// header packets aren't
// audio, so if/when we
// submit them,
// vorbis_synthesis will
// reject them
// suck in the synthesis data and track bitrate
{
int oldsamples = vd.synthesis_pcmout(null, null);
vd.synthesis_blockin(vb);
samptrack += vd.synthesis_pcmout(null, null) - oldsamples;
bittrack += op.bytes * 8;
}
// update the pcm vorbisFile.offset.
if (granulepos != -1 && op.e_o_s == 0)
{
int link = (vorbisFile.skable ? current_link : 0);
int samples;
// this packet has a pcm_offset on it (the last packet
// completed on a page carries the vorbisFile.offset) After processing
// (above), we know the pcm position of the *last* sample
// ready to be returned. Find the vorbisFile.offset of the *first*
//
// As an aside, this trick is inaccurate if we begin
// reading anew right at the last page; the end-of-stream
// granulepos declares the last frame in the stream, and the
// last packet of the last page may be a partial frame.
// So, we need a previous granulepos from an in-sequence page
// to have a reference point. Thus the !op.e_o_s clause above
samples = vd.synthesis_pcmout(null, null);
granulepos -= samples;
for (int i = 0; i < link; i++)
{
granulepos += vorbisFile.pcmlengths[i];
}
pcm_offset = granulepos;
}
return(1);
}
}
}
if (readp == 0)
{
return(0);
}
if (vorbisFile.get_next_page(og, -1, this) < 0)
{
return(0); // eof. leave unitialized
}
// bitrate tracking; add the header's bytes here, the body bytes
// are done by packet above
bittrack += og.header_len * 8;
// has our decoding just traversed a bitstream boundary?
if (decode_ready)
{
if (current_serialno != og.serialno())
{
decode_clear();
}
}
// Do we need to load a new machine before submitting the page?
// This is different in the seekable and non-seekable cases.
//
// In the seekable case, we already have all the header
// information loaded and cached; we just initialize the machine
// with it and continue on our merry way.
//
// In the non-seekable (streaming) case, we'll only be at a
// boundary if we just left the previous logical bitstream and
// we're now nominally at the header of the next bitstream
if (!decode_ready)
{
int i;
if (vorbisFile.skable)
{
current_serialno = og.serialno();
// match the serialno to bitstream section. We use this rather than
// vorbisFile.offset positions to avoid problems near logical bitstream
// boundaries
for (i = 0; i < vorbisFile.links; i++)
{
if (vorbisFile.serialnos[i] == current_serialno)
{
break;
}
}
if (i == vorbisFile.links)
{
return(-1); // sign of a bogus stream. error out,
}
// leave machine uninitialized
current_link = i;
os.init(current_serialno);
os.reset();
}
else
{
// we're streaming
// fetch the three header packets, build the info struct
int[] foo = new int[1];
int ret = vorbisFile.fetch_headers(vorbisFile.vi[0], vorbisFile.vc[0], foo, og, this);
current_serialno = foo[0];
if (ret != 0)
{
return(ret);
}
current_link++;
i = 0;
}
make_decode_ready();
}
os.pagein(og);
}
}
static byte[] convbuffer = new byte[convsize]; // take 8k out of the data segment, not the stack
public static void main(String[] arg)
{
//Stream output = File.OpenWrite("output.bin");
var Name = "Output.ogg";
var OutputBuffer = new MemoryStream();
Stream input = null;
//java.io.InputStream input=System.In;
if (arg.Length > 0)
{
try
{
Name = arg[0];
input = File.OpenRead(arg[0]);
}
catch (Exception e)
{
Console.Error.WriteLine(e);
}
}
else
{
throw (new NotImplementedException("aaaa"));
}
if (input == null)
{
throw (new NotImplementedException("bbb"));
}
var SyncState = new SyncState(); // sync and verify incoming physical bitstream
var StreamState = new StreamState(); // take physical pages, weld into a logical stream of packets
var Page = new Page(); // one Ogg bitstream page. Vorbis packets are inside
var Packet = new Packet(); // one raw packet of data for decode
var Info = new Info(); // struct that stores all the static vorbis bitstream settings
var Comment = new Comment(); // struct that stores all the bitstream user comments
var DspState = new DspState(); // central working state for the packet->PCM decoder
var Block = new Block(DspState); // local working space for packet->PCM decode
byte[] buffer;
int bytes = 0;
// Decode setup
SyncState.Init(); // Now we can read pages
// we repeat if the bitstream is chained
while (true)
{
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 = SyncState.Buffer(4096);
buffer = SyncState.Data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
Console.Error.WriteLine(e);
return;
}
SyncState.wrote(bytes);
// Get the first page.
int _result = SyncState.PageOut(Page);
if (_result != 1)
{
// have we simply run out of data? If so, we're done.
if (bytes < 4096)
{
break;
}
Console.WriteLine(bytes + "; " + _result);
//File.WriteAllBytes();
// error case. Must not be Vorbis data
Console.Error.WriteLine("Input does not appear to be an Ogg bitstream.");
return;
}
// Get the serial number and set up the rest of decode.
// serialno first; use it to set up a logical stream
StreamState.Init(Page.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.
Info.init();
Comment.init();
if (StreamState.pagein(Page) < 0)
{
// error; stream version mismatch perhaps
throw (new Exception("Error reading first page of Ogg bitstream data."));
}
if (StreamState.PacketOut(Packet) != 1)
{
// no page? must not be vorbis
throw (new Exception("Error reading initial header packet."));
}
if (Info.synthesis_headerin(Comment, Packet) < 0)
{
// error case; not a vorbis header
throw (new Exception("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 = SyncState.PageOut(Page);
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)
{
StreamState.pagein(Page); // we can ignore any errors here
// as they'll also become apparent
// at packetout
while (i < 2)
{
result = StreamState.PacketOut(Packet);
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.
throw(new Exception("Corrupt secondary header. Exiting."));
}
Info.synthesis_headerin(Comment, Packet);
i++;
}
}
}
// no harm in not checking before adding more
index = SyncState.Buffer(4096);
buffer = SyncState.Data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
throw(new Exception("Exception", e));
}
if (bytes == 0 && i < 2)
{
throw(new Exception("End of file before finding all Vorbis headers!"));
}
SyncState.wrote(bytes);
}
// Throw the comments plus a few lines about the bitstream we're
// decoding
{
byte[][] ptr = Comment.user_comments;
for (int j = 0; j < ptr.Length; j++)
{
if (ptr[j] == null)
{
break;
}
Console.Error.WriteLine(Util.InternalEncoding.GetString(ptr[j], 0, ptr[j].Length - 1));
}
Console.Error.WriteLine("\nBitstream is {0} channel, {1}Hz", Info.channels, Info.rate);
Console.Error.WriteLine(
"Encoded by: {0}\n",
Util.InternalEncoding.GetString(Comment.vendor, 0, Comment.vendor.Length - 1));
}
convsize = 4096 / Info.channels;
// OK, got and parsed all three headers. Initialize the Vorbis
// packet->PCM decoder.
DspState.synthesis_init(Info); // central decode state
Block.init(DspState); // 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[Info.channels];
// The rest is just a straight decode loop until end of stream
while (eos == 0)
{
while (eos == 0)
{
int result = SyncState.PageOut(Page);
if (result == 0)
{
break; // need more data
}
if (result == -1)
{ // missing or corrupt data at this page position
Console.Error.WriteLine("Corrupt or missing data in bitstream; continuing...");
}
else
{
StreamState.pagein(Page); // can safely ignore errors at
// this point
while (true)
{
result = StreamState.PacketOut(Packet);
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 (Block.synthesis(Packet) == 0)
{ // test for success!
DspState.synthesis_blockin(Block);
}
// **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 = DspState.synthesis_pcmout(_pcm, _index)) > 0)
{
float[][] pcm = _pcm[0];
int bout = (samples < convsize ? samples : convsize);
// convert floats to 16 bit signed ints (host order) and
// interleave
for (i = 0; i < Info.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;
}
if (val < -32768)
{
val = -32768;
}
if (val < 0)
{
val = val | 0x8000;
}
convbuffer[ptr] = (byte)(val);
convbuffer[ptr + 1] = (byte)(((uint)val) >> 8);
ptr += 2 * (Info.channels);
}
}
// System.out.write(convbuffer, 0, 2*vi.channels*bout);
//throw(new NotImplementedException("ccccccccc"));
OutputBuffer.Write(convbuffer, 0, 2 * Info.channels * bout);
// tell libvorbis how
// many samples we
// actually consumed
DspState.synthesis_read(bout);
}
}
}
if (Page.eos() != 0)
{
eos = 1;
}
}
}
if (eos == 0)
{
index = SyncState.Buffer(4096);
buffer = SyncState.Data;
try
{
bytes = input.Read(buffer, index, 4096);
}
catch (Exception e)
{
throw(new Exception("Exception", e));
}
SyncState.wrote(bytes);
if (bytes == 0)
{
eos = 1;
}
}
}
// clean up this logical bitstream; before exit we see if we're
// followed by another [chained]
StreamState.Clear();
// ogg_page and ogg_packet structs always point to storage in
// libvorbis. They're never freed or manipulated directly
Block.clear();
DspState.clear();
Info.Clear(); // must be called last
}
// OK, clean up the framer
SyncState.Clear();
var WaveStream = new WaveStream();
using (var WaveOutputStream = File.OpenWrite(Name + ".wav"))
{
OutputBuffer.Position = 0;
WaveStream.WriteWave(WaveOutputStream, () =>
{
OutputBuffer.CopyTo(WaveOutputStream);
}, NumberOfChannels: 1, SampleRate: 44100);
}
Console.Error.WriteLine("Done.");
}
public AudioFormat ReadHeader(Stream source)
{
input = source;
oy.init(); // Now we can read pages
// 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;
bytes = input.Read(buffer, index, 4096);
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)
{
return(default(AudioFormat));
}
}
// 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();
os.pagein(og);
os.packetout(op);
vi.synthesis_headerin(vc, op);
// 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 packets, 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;
}
vi.synthesis_headerin(vc, op);
i++;
}
}
}
// no harm in not checking before adding more
index = oy.buffer(4096);
buffer = oy.data;
bytes = input.Read(buffer, index, 4096);
oy.wrote(bytes);
}
// 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
AudioFormat format;
format.Channels = vi.channels;
format.BitsPerSample = 16;
format.SampleRate = vi.rate;
return(format);
}