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; }