internal void AddPacket(DataPacket packet)
{
if (packet.IsResync)
{
packet.IsContinuation = false;
if (this._last != null)
this._last.IsContinued = false;
}
if (packet.IsContinuation)
{
if (this._last == null)
throw new InvalidDataException();
if (!this._last.IsContinued)
throw new InvalidDataException();
this._last.MergeWith(packet);
this._last.IsContinued = packet.IsContinued;
}
else
{
Packet packet1 = packet as Packet;
if (packet1 == null)
throw new ArgumentException("Wrong packet datatype", "packet");
if (this._first == null)
{
this._first = packet1;
this._last = packet1;
}
else
this._last = (packet1.Prev = this._last).Next = packet1;
}
PacketReader packetReader = this;
int num = packetReader._eosFound | packet.IsEndOfStream ? 1 : 0;
packetReader._eosFound = num != 0;
}
public void Dispose()
{
_eosFound = true;
_container.DisposePacketReader(this);
_container = null;
_current = null;
if (_first != null)
{
var node = _first;
_first = null;
while (node.Next != null)
{
var temp = node.Next;
node.Next = null;
node = temp;
node.Prev = null;
}
node = null;
}
_last = null;
}
protected override void DoMergeWith(DataPacket continuation)
{
Packet packet1 = continuation as Packet;
if (packet1 == null)
throw new ArgumentException("Incorrect packet type!");
Packet packet2 = this;
int num = packet2.Length + continuation.Length;
packet2.Length = num;
if (this._mergedPacket == null)
this._mergedPacket = packet1;
else
this._mergedPacket.DoMergeWith(continuation);
this.PageGranulePosition = continuation.PageGranulePosition;
this.PageSequenceNumber = continuation.PageSequenceNumber;
}
protected override void DoMergeWith(NVorbis.DataPacket continuation)
{
var op = continuation as Packet;
if (op == null) throw new ArgumentException("Incorrect packet type!");
Length += continuation.Length;
if (_mergedPacket == null)
{
_mergedPacket = op;
}
else
{
_mergedPacket.DoMergeWith(continuation);
}
// per the spec, a partial packet goes with the next page's granulepos. we'll go ahead and assign it to the next page as well
PageGranulePosition = continuation.PageGranulePosition;
PageSequenceNumber = continuation.PageSequenceNumber;
}
internal void AddPacket(DataPacket packet)
{
// if the packet is a resync, it cannot be a continuation...
if (packet.IsResync)
{
packet.IsContinuation = false;
if (_last != null) _last.IsContinued = false;
}
if (packet.IsContinuation)
{
// if we get here, the stream is invalid if there isn't a previous packet
if (_last == null) throw new InvalidDataException();
// if the last packet isn't continued, something is wrong
if (!_last.IsContinued) throw new InvalidDataException();
_last.MergeWith(packet);
_last.IsContinued = packet.IsContinued;
}
else
{
var p = packet as Packet;
if (p == null) throw new ArgumentException("Wrong packet datatype", "packet");
if (_first == null)
{
// this is the first packet to add, so just set first & last to point at it
_first = p;
_last = p;
}
else
{
// swap the new packet in to the last position (remember, we're doubly-linked)
_last = ((p.Prev = _last).Next = p);
}
}
_eosFound |= packet.IsEndOfStream;
}
internal DataPacket GetNextPacket()
{
while (this._last == null || this._last.IsContinued || this._current == this._last)
{
this.GetMorePackets();
if (this._eosFound)
{
if (this._last.IsContinued)
{
this._last = this._last.Prev;
this._last.Next.Prev = (Packet) null;
this._last.Next = (Packet) null;
}
if (this._current == this._last)
throw new EndOfStreamException();
}
}
DataPacket dataPacket = this._current != null ? (DataPacket) (this._current = this._current.Next) : (DataPacket) (this._current = this._first);
if (dataPacket.IsContinued)
throw new InvalidDataException();
dataPacket.Reset();
return dataPacket;
}
// The Vorbis header is in three packets; the initial small packet in
// the first page that identifies basic parameters, a second packet
// with bitstream comments and a third packet that holds the
// codebook.
public int SynthesisHeaderIn(Comment Comment, Packet Packet)
{
var Buffer = new NVorbis.Ogg.BBuffer();
if (Packet != null)
{
Buffer.ReadInit(Packet.packet_base, Packet.packet, Packet.bytes);
// Which of the three types of header is this?
// Also verify header-ness, vorbis
{
byte[] buffer = new byte[6];
int packtype = Buffer.Read(8);
Buffer.Read(buffer, 6);
if (buffer[0] != 'v' || buffer[1] != 'o' || buffer[2] != 'r' || buffer[3] != 'b'
|| buffer[4] != 'i' || buffer[5] != 's')
{
// not a vorbis header
return (-1);
}
switch (packtype)
{
case 0x01: // least significant *bit* is read first
if (Packet.b_o_s == 0)
{
// Not the initial packet
return (-1);
}
if (Rate != 0)
{
// previously initialized info header
return (-1);
}
return (UnpackInfo(Buffer));
case 0x03: // least significant *bit* is read first
if (Rate == 0)
{
// um... we didn't get the initial header
return (-1);
}
return (Comment.unpack(Buffer));
case 0x05: // least significant *bit* is read first
if (Rate == 0 || Comment.vendor == null)
{
// um... we didn;t get the initial header or comments yet
return (-1);
}
return (UnpackBooks(Buffer));
default:
// Not a valid vorbis header type
//return(-1);
break;
}
}
}
return (-1);
}
public int BlockSize(Packet Packet)
{
//codec_setup_info
var Buffer = new NVorbis.Ogg.BBuffer();
int mode;
Buffer.ReadInit(Packet.packet_base, Packet.packet, Packet.bytes);
/* Check the packet type */
if (Buffer.Read(1) != 0)
{
/* Oops. This is not an audio data packet */
return (OV_ENOTAUDIO);
}
{
int modebits = 0;
uint v = (uint)Modes;
while (v > 1)
{
modebits++;
v >>= 1;
}
/* read our mode and pre/post windowsize */
mode = Buffer.Read(modebits);
}
if (mode == -1)
return (OV_EBADPACKET);
return (blocksizes[ModeParam[mode].blockflag]);
}
Packet FindPacketInPage(Packet pagePacket, long targetGranulePos, Func<DataPacket, DataPacket, int> packetGranuleCountCallback)
{
var lastPacketInPage = GetLastPacketInPage(pagePacket);
if (lastPacketInPage == null)
{
return null;
}
// return the packet the granule position is in
var packet = lastPacketInPage;
do
{
if (!packet.GranuleCount.HasValue)
{
// we don't know its length or position...
// if it's the last packet in the page, it gets the page's granule position. Otherwise, calc it.
if (packet == lastPacketInPage)
{
packet.GranulePosition = packet.PageGranulePosition;
}
else
{
packet.GranulePosition = packet.Next.GranulePosition - packet.Next.GranuleCount.Value;
}
// if it's the last packet in the stream, it might be a partial. The spec says the last packet has to be on its own page, so if it is not assume the stream was truncated.
if (packet == _last && _eosFound && packet.Prev.PageSequenceNumber < packet.PageSequenceNumber)
{
packet.GranuleCount = (int)(packet.GranulePosition - packet.Prev.PageGranulePosition);
}
else if (packet.Prev != null)
{
packet.Prev.Reset();
packet.Reset();
packet.GranuleCount = packetGranuleCountCallback(packet, packet.Prev);
}
else
{
// probably the first data packet...
if (packet.GranulePosition > packet.Next.GranulePosition - packet.Next.GranuleCount)
{
throw new InvalidOperationException("First data packet size mismatch");
}
packet.GranuleCount = (int)packet.GranulePosition;
}
}
// we now know the granule position and count of the packet... is the target within that range?
if (targetGranulePos <= packet.GranulePosition && targetGranulePos > packet.GranulePosition - packet.GranuleCount)
{
// make sure the previous packet has a position too
if (packet.Prev != null && !packet.Prev.GranuleCount.HasValue)
{
packet.Prev.GranulePosition = packet.GranulePosition - packet.GranuleCount.Value;
}
return packet;
}
packet = packet.Prev;
} while (packet != null && packet.PageSequenceNumber == lastPacketInPage.PageSequenceNumber);
// couldn't find it, but maybe that's because something glitched in the file...
// we're doing this in case there's a dicontinuity in the file... It's not perfect, but it'll work
if (packet != null && packet.PageGranulePosition < targetGranulePos)
{
packet.GranulePosition = packet.PageGranulePosition;
return packet.Next;
}
return null;
}
Packet GetLastPacketInPage(Packet packet)
{
if (packet != null)
{
var pageSeqNumber = packet.PageSequenceNumber;
while (packet.Next != null && packet.Next.PageSequenceNumber == pageSeqNumber)
{
packet = packet.Next;
}
while (packet != null && packet.IsContinued)
{
// gotta go grab the next page
if (_eosFound)
{
packet = null;
}
else
{
_container.GatherNextPage(_streamSerial);
if (_eosFound)
{
packet = null;
}
}
}
}
return packet;
}
Packet GetLastPacketInPage(Packet packet)
{
if (packet != null)
{
var pageSeqNumber = packet.PageSequenceNumber;
while (packet.Next != null && packet.Next.PageSequenceNumber == pageSeqNumber)
{
packet = packet.Next;
}
if (packet != null && packet.IsContinued)
{
// move to the *actual* last packet of the page... If .Prev is null, something is wrong and we can't seek anyway
packet = packet.Prev;
}
}
return packet;
}
bool AddPage(PageHeader hdr)
{
// get our packet reader (create one if we have to)
PacketReader packetReader;
if (!_packetReaders.TryGetValue(hdr.StreamSerial, out packetReader))
{
packetReader = new PacketReader(this, hdr.StreamSerial);
}
// save off the container bits
packetReader.ContainerBits += _containerBits;
_containerBits = 0;
// get our flags prepped
var isContinued = false;
var isContinuation = (hdr.Flags & PageFlags.ContinuesPacket) == PageFlags.ContinuesPacket;
var isEOS = false;
var isResync = hdr.IsResync;
// add all the packets, making sure to update flags as needed
var dataOffset = hdr.DataOffset;
var cnt = hdr.PacketSizes.Length;
foreach (var size in hdr.PacketSizes)
{
var packet = new Packet(this, dataOffset, size)
{
PageGranulePosition = hdr.GranulePosition,
IsEndOfStream = isEOS,
PageSequenceNumber = hdr.SequenceNumber,
IsContinued = isContinued,
IsContinuation = isContinuation,
IsResync = isResync,
};
packetReader.AddPacket(packet);
// update the offset into the stream for each packet
dataOffset += size;
// only the first packet in a page can be a continuation or resync
isContinuation = false;
isResync = false;
// only the last packet in a page can be continued or flagged end of stream
if (--cnt == 1)
{
isContinued = hdr.LastPacketContinues;
isEOS = (hdr.Flags & PageFlags.EndOfStream) == PageFlags.EndOfStream;
}
}
// if the packet reader list doesn't include the serial in question, add it to the list and indicate a new stream to the caller
if (!_packetReaders.ContainsKey(hdr.StreamSerial))
{
_packetReaders.Add(hdr.StreamSerial, packetReader);
return true;
}
else
{
// otherwise, indicate an existing stream to the caller
return false;
}
}
private bool AddPage(ContainerReader.PageHeader hdr)
{
PacketReader packetReader;
if (!this._packetReaders.TryGetValue(hdr.StreamSerial, out packetReader))
packetReader = new PacketReader(this, hdr.StreamSerial);
bool flag1 = false;
bool flag2 = (hdr.Flags & PageFlags.ContinuesPacket) == PageFlags.ContinuesPacket;
bool flag3 = (hdr.Flags & PageFlags.EndOfStream) == PageFlags.EndOfStream;
bool flag4 = hdr.IsResync;
int offset = 0;
int length1 = hdr.PacketSizes.Length;
foreach (int length2 in hdr.PacketSizes)
{
Packet packet1 = new Packet(this._stream, hdr.DataOffset + (long) offset, length2);
packet1.PageGranulePosition = hdr.GranulePosition;
packet1.IsEndOfStream = flag3;
packet1.PageSequenceNumber = hdr.SequenceNumber;
packet1.IsContinued = flag1;
packet1.IsContinuation = flag2;
packet1.IsResync = flag4;
Packet packet2 = packet1;
packet2.SetBuffer(hdr.SavedBuffer, offset);
packetReader.AddPacket((DataPacket) packet2);
offset += length2;
flag2 = false;
flag4 = false;
if (--length1 == 1)
flag1 = hdr.LastPacketContinues;
}
if (!this._packetReaders.ContainsKey(hdr.StreamSerial))
{
int streamSerial = hdr.StreamSerial;
this._packetReaders.Add(streamSerial, packetReader);
this._eosFlags.Add(streamSerial, flag3);
this._streamSerials.Add(streamSerial);
return true;
}
else
{
Dictionary<int, bool> dictionary;
int streamSerial;
(dictionary = this._eosFlags)[streamSerial = hdr.StreamSerial] = dictionary[streamSerial] | flag3;
return false;
}
}
internal void SeekToPacket(int index)
{
this._current = this.GetPacketByIndex(index).Prev;
}
internal void AddPacket(Packet packet)
{
lock (_packetLock)
{
// if we've already found the end of the stream, don't accept any more packets
if (_eosFound) return;
// if the packet is a resync, it cannot be a continuation...
if (packet.IsResync)
{
packet.IsContinuation = false;
if (_last != null) _last.IsContinued = false;
}
if (packet.IsContinuation)
{
// if we get here, the stream is invalid if there isn't a previous packet
if (_last == null) throw new Exception();
// if the last packet isn't continued, something is wrong
if (!_last.IsContinued) throw new Exception();
_last.MergeWith(packet);
_last.IsContinued = packet.IsContinued;
}
else
{
var p = packet as Packet;
if (p == null) throw new Exception("Wrong packet datatype+packet");
if (_first == null)
{
// this is the first packet to add, so just set first & last to point at it
_first = p;
_last = p;
}
else
{
// swap the new packet in to the last position (remember, we're doubly-linked)
_last = ((p.Prev = _last).Next = p);
}
}
if (packet.IsEndOfStream)
{
SetEndOfStream();
}
}
}
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.");
}
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;
}
