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.");
}
public Page Copy(Page p)
{
byte[] tmp = new byte[header_len];
Array.Copy(header_base, header, tmp, 0, header_len);
p.header_len = header_len;
p.header_base = tmp;
p.header = 0;
tmp = new byte[body_len];
Array.Copy(body_base, body, tmp, 0, body_len);
p.body_len = body_len;
p.body_base = tmp;
p.body = 0;
return p;
}
/// <summary>
/// sync the stream and get a page. Keep trying until we find a page.
/// Supress 'sync errors' after reporting the first.
///
/// </summary>
/// <param name="og"></param>
/// <returns>
/// -1) recapture (hole in data)
/// 0) need more data
/// 1) page returned
///
/// Returns pointers into buffered data; invalidated by next call to
/// _stream, _clear, _init, or _buffer
/// </returns>
public int PageOut(Page og)
{
// All we need to do is verify a page at the head of the
// stream buffer. If it doesn't verify, we look for the
// next potential frame.
while (true)
{
int ret = PageSeek(og);
// have a page
if (ret > 0) return 1;
// need more data
if (ret == 0) return 0;
// head did not start a synced page... skipped some bytes
if (Unsynced == 0)
{
Unsynced = 1;
return -1;
}
// loop. keep looking
}
}
public int PageSeek(Page og)
{
int page = Returned;
int next;
int bytes = Fill - Returned;
if (HeaderBytes == 0)
{
int _headerbytes, i;
if (bytes < 27)
return (0); // not enough for a header
/* verify capture pattern */
if (Data[page] != 'O' || Data[page + 1] != 'g' || Data[page + 2] != 'g'
|| Data[page + 3] != 'S')
{
HeaderBytes = 0;
BodyBytes = 0;
// search for possible capture
next = 0;
for (int ii = 0; ii < bytes - 1; ii++)
{
if (Data[page + 1 + ii] == 'O')
{
next = page + 1 + ii;
break;
}
}
//next=memchr(page+1,'O',bytes-1);
if (next == 0)
next = Fill;
Returned = next;
return (-(next - page));
}
_headerbytes = (Data[page + 26] & 0xff) + 27;
if (bytes < _headerbytes)
return (0); // not enough for header + seg table
// count up body length in the segment table
for (i = 0; i < (Data[page + 26] & 0xff); i++)
{
BodyBytes += (Data[page + 27 + i] & 0xff);
}
HeaderBytes = _headerbytes;
}
if (BodyBytes + HeaderBytes > bytes)
return (0);
// The whole test page is buffered. Verify the checksum
lock (chksum)
{
// Grab the checksum bytes, set the header field to zero
Array.Copy(Data, page + 22, chksum, 0, 4);
Data[page + 22] = 0;
Data[page + 23] = 0;
Data[page + 24] = 0;
Data[page + 25] = 0;
// set up a temp page struct and recompute the checksum
Page log = _pageseek;
log.header_base = Data;
log.header = page;
log.header_len = HeaderBytes;
log.body_base = Data;
log.body = page + HeaderBytes;
log.body_len = BodyBytes;
log.WriteChecksum();
// Compare
if (chksum[0] != Data[page + 22] || chksum[1] != Data[page + 23]
|| chksum[2] != Data[page + 24] || chksum[3] != Data[page + 25])
{
// D'oh. Mismatch! Corrupt page (or miscapture and not a page at all)
// replace the computed checksum with the one actually read in
Array.Copy(chksum, 0, Data, page + 22, 4);
// Bad checksum. Lose sync */
HeaderBytes = 0;
BodyBytes = 0;
// search for possible capture
next = 0;
for (int ii = 0; ii < bytes - 1; ii++)
{
if (Data[page + 1 + ii] == 'O')
{
next = page + 1 + ii;
break;
}
}
//next=memchr(page+1,'O',bytes-1);
if (next == 0)
next = Fill;
Returned = next;
return (-(next - page));
}
}
// yes, have a whole page all ready to go
{
page = Returned;
if (og != null)
{
og.header_base = Data;
og.header = page;
og.header_len = HeaderBytes;
og.body_base = Data;
og.body = page + HeaderBytes;
og.body_len = BodyBytes;
}
Unsynced = 0;
Returned += (bytes = HeaderBytes + BodyBytes);
HeaderBytes = 0;
BodyBytes = 0;
return (bytes);
}
}
private void DecodeInit()
{
convbuffer = new byte[convsize]; // take 8k out of the data segment, not the stack
SyncState = new SyncState(); // sync and verify incoming physical bitstream
StreamState = new StreamState(); // take physical pages, weld into a logical stream of packets
Page = new Page(); // one Ogg bitstream page. Vorbis packets are inside
Packet = new Packet(); // one raw packet of data for decode
Info = new Info(); // struct that stores all the static vorbis bitstream settings
Comment = new Comment(); // struct that stores all the bitstream user comments
DspState = new DspState(); // central working state for the packet->PCM decoder
Block = new Block(DspState); // local working space for packet->PCM decode
bytes = 0;
}
