public ReadBits ( int count ) : ulong | ||
count | int | The number of bits to read. |
Результат | ulong |
internal static VorbisMode Init(VorbisStreamDecoder vorbis, DataPacket packet) { var mode = new VorbisMode(vorbis); mode.BlockFlag = packet.ReadBit(); mode.WindowType = (int)packet.ReadBits(16); mode.TransformType = (int)packet.ReadBits(16); var mapping = (int)packet.ReadBits(8); if (mode.WindowType != 0 || mode.TransformType != 0 || mapping >= vorbis.Maps.Length) throw new InvalidDataException(); mode.Mapping = vorbis.Maps[mapping]; mode.BlockSize = mode.BlockFlag ? vorbis.Block1Size : vorbis.Block0Size; // now pre-calc the window(s)... if (mode.BlockFlag) { // long block mode._windows = new float[4][]; mode._windows[0] = new float[vorbis.Block1Size]; mode._windows[1] = new float[vorbis.Block1Size]; mode._windows[2] = new float[vorbis.Block1Size]; mode._windows[3] = new float[vorbis.Block1Size]; } else { // short block mode._windows = new float[1][]; mode._windows[0] = new float[vorbis.Block0Size]; } mode.CalcWindows(); return mode; }
internal static VorbisMode Init(VorbisStreamDecoder vorbis, DataPacket packet) { VorbisMode vorbisMode = new VorbisMode(vorbis); vorbisMode.BlockFlag = packet.ReadBit(); vorbisMode.WindowType = (int) packet.ReadBits(16); vorbisMode.TransformType = (int) packet.ReadBits(16); int index = (int) packet.ReadBits(8); if (vorbisMode.WindowType != 0 || vorbisMode.TransformType != 0 || index >= vorbis.Maps.Length) throw new InvalidDataException(); vorbisMode.Mapping = vorbis.Maps[index]; vorbisMode.BlockSize = vorbisMode.BlockFlag ? vorbis.Block1Size : vorbis.Block0Size; if (vorbisMode.BlockFlag) { vorbisMode._windows = new float[4][]; vorbisMode._windows[0] = new float[vorbis.Block1Size]; vorbisMode._windows[1] = new float[vorbis.Block1Size]; vorbisMode._windows[2] = new float[vorbis.Block1Size]; vorbisMode._windows[3] = new float[vorbis.Block1Size]; } else { vorbisMode._windows = new float[1][]; vorbisMode._windows[0] = new float[vorbis.Block0Size]; } vorbisMode.CalcWindows(); return vorbisMode; }
internal void Init(DataPacket packet) { if ((long) packet.ReadBits(24) != 5653314L) throw new InvalidDataException(); this.Dimensions = (int) packet.ReadBits(16); this.Entries = (int) packet.ReadBits(24); this.Lengths = new int[this.Entries]; this.InitTree(packet); this.InitLookupTable(packet); }
protected override void Init(DataPacket packet) { this._order = (int) packet.ReadBits(8); this._rate = (int) packet.ReadBits(16); this._bark_map_size = (int) packet.ReadBits(16); this._ampBits = (int) packet.ReadBits(6); this._ampOfs = (int) packet.ReadBits(8); this._books = new VorbisCodebook[(int) packet.ReadBits(4) + 1]; for (int index = 0; index < this._books.Length; ++index) this._books[index] = this._vorbis.Books[(int) packet.ReadBits(8)]; this._bookBits = Utils.ilog(this._books.Length); this._barkMaps = new Dictionary<int, float[]>(); this._barkMaps[this._vorbis.Block0Size] = this.SynthesizeBarkCurve(this._vorbis.Block0Size); this._barkMaps[this._vorbis.Block1Size] = this.SynthesizeBarkCurve(this._vorbis.Block1Size); }
protected override void Init(DataPacket packet) { int length1 = 1; if (packet.ReadBit()) length1 += (int) packet.ReadBits(4); int length2 = 0; if (packet.ReadBit()) length2 = (int) packet.ReadBits(8) + 1; int count = Utils.ilog(this._vorbis._channels - 1); this.CouplingSteps = new VorbisMapping.CouplingStep[length2]; for (int index = 0; index < length2; ++index) { int num1 = (int) packet.ReadBits(count); int num2 = (int) packet.ReadBits(count); if (num1 == num2 || num1 > this._vorbis._channels - 1 || num2 > this._vorbis._channels - 1) throw new InvalidDataException(); this.CouplingSteps[index] = new VorbisMapping.CouplingStep() { Angle = num2, Magnitude = num1 }; } if ((long) packet.ReadBits(2) != 0L) throw new InvalidDataException(); int[] numArray = new int[this._vorbis._channels]; if (length1 > 1) { for (int index = 0; index < this.ChannelSubmap.Length; ++index) { numArray[index] = (int) packet.ReadBits(4); if (numArray[index] >= length1) throw new InvalidDataException(); } } this.Submaps = new VorbisMapping.Submap[length1]; for (int index1 = 0; index1 < length1; ++index1) { long num = (long) packet.ReadBits(8); int index2 = (int) packet.ReadBits(8); if (index2 >= this._vorbis.Floors.Length) throw new InvalidDataException(); if ((int) packet.ReadBits(8) >= this._vorbis.Residues.Length) throw new InvalidDataException(); this.Submaps[index1] = new VorbisMapping.Submap() { Floor = this._vorbis.Floors[index2], Residue = this._vorbis.Residues[index2] }; } this.ChannelSubmap = new VorbisMapping.Submap[this._vorbis._channels]; for (int index = 0; index < this.ChannelSubmap.Length; ++index) this.ChannelSubmap[index] = this.Submaps[numArray[index]]; }
internal void Init(DataPacket packet) { // first, check the sync pattern var chkVal = packet.ReadBits(24); if (chkVal != 0x564342UL) throw new Exception(); // get the counts Dimensions = (int)packet.ReadBits(16); Entries = (int)packet.ReadBits(24); // init the storage Lengths = new int[Entries]; InitTree(packet); InitLookupTable(packet); }
internal static VorbisMapping Init(VorbisStreamDecoder vorbis, DataPacket packet) { int num = (int) packet.ReadBits(16); VorbisMapping vorbisMapping = (VorbisMapping) null; if (num == 0) vorbisMapping = (VorbisMapping) new VorbisMapping.Mapping0(vorbis); if (vorbisMapping == null) throw new InvalidDataException(); vorbisMapping.Init(packet); return vorbisMapping; }
internal void Init(DataPacket packet) { // first, check the sync pattern var chkVal = packet.ReadBits(24); if (chkVal != 0x564342UL) { throw new InvalidDataException(); } // get the counts Dimensions = (int)packet.ReadBits(16); Entries = (int)packet.ReadBits(24); // init the storage Lengths = new int[Entries]; InitTree(packet); InitLookupTable(packet); }
internal static VorbisTime Init(VorbisStreamDecoder vorbis, DataPacket packet) { int num = (int) packet.ReadBits(16); VorbisTime vorbisTime = (VorbisTime) null; if (num == 0) vorbisTime = (VorbisTime) new VorbisTime.Time0(vorbis); if (vorbisTime == null) throw new InvalidDataException(); vorbisTime.Init(packet); return vorbisTime; }
protected override void Init(DataPacket packet) { var submapCount = 1; if (packet.ReadBit()) submapCount += (int)packet.ReadBits(4); // square polar mapping var couplingSteps = 0; if (packet.ReadBit()) { couplingSteps = (int)packet.ReadBits(8) + 1; } var couplingBits = Utils.ilog(_vorbis._channels - 1); CouplingSteps = new CouplingStep[couplingSteps]; for (int j = 0; j < couplingSteps; j++) { var magnitude = (int)packet.ReadBits(couplingBits); var angle = (int)packet.ReadBits(couplingBits); if (magnitude == angle || magnitude > _vorbis._channels - 1 || angle > _vorbis._channels - 1) throw new Exception(); CouplingSteps[j] = new CouplingStep { Angle = angle, Magnitude = magnitude }; } // reserved bits if (packet.ReadBits(2) != 0UL) throw new Exception(); // channel multiplex var mux = new int[_vorbis._channels]; if (submapCount > 1) { for (int c = 0; c < ChannelSubmap.Length; c++) { mux[c] = (int)packet.ReadBits(4); if (mux[c] >= submapCount) throw new Exception(); } } // submaps Submaps = new Submap[submapCount]; for (int j = 0; j < submapCount; j++) { packet.ReadBits(8); // unused placeholder var floorNum = (int)packet.ReadBits(8); if (floorNum >= _vorbis.Floors.Length) throw new Exception(); var residueNum = (int)packet.ReadBits(8); if (residueNum >= _vorbis.Residues.Length) throw new Exception(); Submaps[j] = new Submap { Floor = _vorbis.Floors[floorNum], Residue = _vorbis.Residues[floorNum] }; } ChannelSubmap = new Submap[_vorbis._channels]; for (int c = 0; c < ChannelSubmap.Length; c++) { ChannelSubmap[c] = Submaps[mux[c]]; } }
protected override void Init(DataPacket packet) { this._begin = (int) packet.ReadBits(24); this._end = (int) packet.ReadBits(24); this._partitionSize = (int) packet.ReadBits(24) + 1; this._classifications = (int) packet.ReadBits(6) + 1; this._classBookNum = (int) packet.ReadBits(8); this._classBook = this._vorbis.Books[this._classBookNum]; this._cascade = new int[this._classifications]; int length = 0; int val2 = 0; for (int index = 0; index < this._classifications; ++index) { int num1 = 0; int num2 = (int) packet.ReadBits(3); if (packet.ReadBit()) num1 = (int) packet.ReadBits(5); this._cascade[index] = num1 << 3 | num2; length += VorbisResidue.Residue0.icount(this._cascade[index]); val2 = Math.Max(Utils.ilog(this._cascade[index]), val2); } this._maxPasses = val2; int[] numArray = new int[length]; for (int index = 0; index < length; ++index) numArray[index] = (int) packet.ReadBits(8); int num3 = 0; this._books = new VorbisCodebook[this._classifications][]; this._bookNums = new int[this._classifications][]; for (int index1 = 0; index1 < this._classifications; ++index1) { this._books[index1] = new VorbisCodebook[8]; this._bookNums[index1] = new int[8]; int num1 = 1; int index2 = 0; while (num1 < 256) { if ((this._cascade[index1] & num1) == num1) { int index3 = numArray[num3++]; this._books[index1][index2] = this._vorbis.Books[index3]; this._bookNums[index1][index2] = index3; if (this._books[index1][index2].MapType == 0) throw new InvalidDataException(); } num1 <<= 1; ++index2; } } this._classWordsPerCodeWord = this._classBook.Dimensions; this._nToRead = this._end - this._begin; this._partsToRead = this._nToRead / this._partitionSize; this._partWords = (this._partsToRead + this._classWordsPerCodeWord - 1) / this._classWordsPerCodeWord; }
internal static VorbisMapping Init(VorbisStreamDecoder vorbis, DataPacket packet) { var type = (int)packet.ReadBits(16); VorbisMapping mapping = null; switch (type) { case 0: mapping = new Mapping0(vorbis); break; } if (mapping == null) throw new Exception(); mapping.Init(packet); return mapping; }
private VorbisCodebook(DataPacket packet, int number) { // save off the book number BookNum = number; // first, check the sync pattern var chkVal = packet.ReadBits(24); if (chkVal != 0x564342UL) { throw new InvalidDataException(); } // get the counts Dimensions = (int)packet.ReadBits(16); Entries = (int)packet.ReadBits(24); // init the storage Lengths = new int[Entries]; InitTree(packet); InitLookupTable(packet); }
private void ProcessStreamHeader(DataPacket packet) { this._pagesSeen.Add(packet.PageSequenceNumber); long bitsRead = packet.BitsRead; if (packet.ReadInt32() != 0) { throw new InvalidDataException("Only Vorbis stream version 0 is supported."); } this._channels = (int)packet.ReadByte(); this._sampleRate = packet.ReadInt32(); this._upperBitrate = packet.ReadInt32(); this._nominalBitrate = packet.ReadInt32(); this._lowerBitrate = packet.ReadInt32(); this.Block0Size = 1 << (int)packet.ReadBits(4); this.Block1Size = 1 << (int)packet.ReadBits(4); if (this._nominalBitrate == 0 && this._upperBitrate > 0 && this._lowerBitrate > 0) { this._nominalBitrate = (this._upperBitrate + this._lowerBitrate) / 2; } this._metaBits += packet.BitsRead - bitsRead + 8L; this._wasteHdrBits += (long)(8 * packet.Length) - packet.BitsRead; }
internal static VorbisTime Init(VorbisStreamDecoder vorbis, DataPacket packet) { var type = (int)packet.ReadBits(16); VorbisTime time = null; switch (type) { case 0: time = new Time0(vorbis); break; } if (time == null) throw new InvalidDataException(); time.Init(packet); return time; }
protected override void Init(DataPacket packet) { // this is pretty well stolen directly from libvorbis... BSD license _order = (int)packet.ReadBits(8); _rate = (int)packet.ReadBits(16); _bark_map_size = (int)packet.ReadBits(16); _ampBits = (int)packet.ReadBits(6); _ampOfs = (int)packet.ReadBits(8); _books = new VorbisCodebook[(int)packet.ReadBits(4) + 1]; if (_order < 1 || _rate < 1 || _bark_map_size < 1 || _books.Length == 0) { throw new InvalidDataException(); } _ampDiv = (1 << _ampBits) - 1; for (int i = 0; i < _books.Length; i++) { var num = (int)packet.ReadBits(8); if (num < 0 || num >= _vorbis.Books.Length) { throw new InvalidDataException(); } var book = _vorbis.Books[num]; if (book.MapType == 0 || book.Dimensions < 1) { throw new InvalidDataException(); } _books[i] = book; } _bookBits = Utils.ilog(_books.Length); _barkMaps = new Dictionary <int, int[]>(); _barkMaps[_vorbis.Block0Size] = SynthesizeBarkCurve(_vorbis.Block0Size / 2); _barkMaps[_vorbis.Block1Size] = SynthesizeBarkCurve(_vorbis.Block1Size / 2); _wMap = new Dictionary <int, float[]>(); _wMap[_vorbis.Block0Size] = SynthesizeWDelMap(_vorbis.Block0Size / 2); _wMap[_vorbis.Block1Size] = SynthesizeWDelMap(_vorbis.Block1Size / 2); _reusablePacketData = new PacketData0[_vorbis._channels]; for (int i = 0; i < _reusablePacketData.Length; i++) { _reusablePacketData[i] = new PacketData0() { Coeff = new float[_order + 1] }; } }
internal static VorbisMode Init(VorbisStreamDecoder vorbis, DataPacket packet) { var mode = new VorbisMode(vorbis); mode.BlockFlag = packet.ReadBit(); mode.WindowType = (int)packet.ReadBits(16); mode.TransformType = (int)packet.ReadBits(16); var mapping = (int)packet.ReadBits(8); if (mode.WindowType != 0 || mode.TransformType != 0 || mapping >= vorbis.Maps.Length) { throw new Exception(); } mode.Mapping = vorbis.Maps[mapping]; mode.BlockSize = mode.BlockFlag ? vorbis.Block1Size : vorbis.Block0Size; // now pre-calc the window(s)... if (mode.BlockFlag) { // long block mode._windows = new float[4][]; mode._windows[0] = new float[vorbis.Block1Size]; mode._windows[1] = new float[vorbis.Block1Size]; mode._windows[2] = new float[vorbis.Block1Size]; mode._windows[3] = new float[vorbis.Block1Size]; } else { // short block mode._windows = new float[1][]; mode._windows[0] = new float[vorbis.Block0Size]; } mode.CalcWindows(); return(mode); }
internal static VorbisFloor Init(VorbisStreamDecoder vorbis, DataPacket packet) { var type = (int)packet.ReadBits(16); VorbisFloor floor = null; switch (type) { case 0: floor = new Floor0(vorbis); break; case 1: floor = new Floor1(vorbis); break; } if (floor == null) throw new InvalidDataException(); floor.Init(packet); return floor; }
internal static VorbisTime Init(VorbisStreamDecoder vorbis, DataPacket packet) { int num = (int)packet.ReadBits(16); VorbisTime vorbisTime = (VorbisTime)null; if (num == 0) { vorbisTime = (VorbisTime) new VorbisTime.Time0(vorbis); } if (vorbisTime == null) { throw new InvalidDataException(); } vorbisTime.Init(packet); return(vorbisTime); }
internal static VorbisMapping Init(VorbisStreamDecoder vorbis, DataPacket packet) { int num = (int)packet.ReadBits(16); VorbisMapping vorbisMapping = null; if (num == 0) { vorbisMapping = new Mapping0(vorbis); } if (vorbisMapping == null) { throw new InvalidDataException(); } vorbisMapping.Init(packet); return(vorbisMapping); }
internal static VorbisResidue Init(VorbisStreamDecoder vorbis, DataPacket packet) { var type = (int)packet.ReadBits(16); VorbisResidue residue = null; switch (type) { case 0: residue = new Residue0(vorbis); break; case 1: residue = new Residue1(vorbis); break; case 2: residue = new Residue2(vorbis); break; } if (residue == null) throw new InvalidDataException(); residue.Init(packet); return residue; }
internal static VorbisTime Init(VorbisStreamDecoder vorbis, DataPacket packet) { var type = (int)packet.ReadBits(16); VorbisTime time = null; switch (type) { case 0: time = new Time0(vorbis); break; } if (time == null) { throw new InvalidDataException(); } time.Init(packet); return(time); }
internal static VorbisFloor Init(VorbisStreamDecoder vorbis, DataPacket packet) { int num = (int) packet.ReadBits(16); VorbisFloor vorbisFloor = (VorbisFloor) null; switch (num) { case 0: vorbisFloor = (VorbisFloor) new VorbisFloor.Floor0(vorbis); break; case 1: vorbisFloor = (VorbisFloor) new VorbisFloor.Floor1(vorbis); break; } if (vorbisFloor == null) throw new InvalidDataException(); vorbisFloor.Init(packet); return vorbisFloor; }
internal static VorbisMapping Init(VorbisStreamDecoder vorbis, DataPacket packet) { var type = (int)packet.ReadBits(16); VorbisMapping mapping = null; switch (type) { case 0: mapping = new Mapping0(vorbis); break; } if (mapping == null) { throw new InvalidDataException(); } mapping.Init(packet); return(mapping); }
protected override void Init(DataPacket packet) { this._order = (int)packet.ReadBits(8); this._rate = (int)packet.ReadBits(16); this._bark_map_size = (int)packet.ReadBits(16); this._ampBits = (int)packet.ReadBits(6); this._ampOfs = (int)packet.ReadBits(8); this._books = new VorbisCodebook[(int)packet.ReadBits(4) + 1]; for (int index = 0; index < this._books.Length; ++index) { this._books[index] = this._vorbis.Books[(int)packet.ReadBits(8)]; } this._bookBits = Utils.ilog(this._books.Length); this._barkMaps = new Dictionary <int, float[]>(); this._barkMaps[this._vorbis.Block0Size] = this.SynthesizeBarkCurve(this._vorbis.Block0Size); this._barkMaps[this._vorbis.Block1Size] = this.SynthesizeBarkCurve(this._vorbis.Block1Size); }
internal static VorbisFloor Init(VorbisStreamDecoder vorbis, DataPacket packet) { var type = (int)packet.ReadBits(16); VorbisFloor floor = null; switch (type) { case 0: floor = new Floor0(vorbis); break; case 1: floor = new Floor1(vorbis); break; } if (floor == null) { throw new InvalidDataException(); } floor.Init(packet); return(floor); }
public override void Init(DataPacket packet) { _order = (int)packet.ReadBits(8); _rate = (int)packet.ReadBits(16); _bark_map_size = (int)packet.ReadBits(16); _ampBits = (int)packet.ReadBits(6); _ampOfs = (int)packet.ReadBits(8); _books = new VorbisCodebook[(int)packet.ReadBits(4) + 1]; if (_order < 1 || _rate < 1 || _bark_map_size < 1 || _books.Length == 0) { throw new InvalidDataException(); } _ampDiv = (1 << _ampBits) - 1; for (int i = 0; i < _books.Length; i++) { int num = (int)packet.ReadBits(8); if (num < 0 || num >= _vorbis.Books.Length) { throw new InvalidDataException(); } VorbisCodebook vorbisCodebook = _vorbis.Books[num]; if (vorbisCodebook.MapType == 0 || vorbisCodebook.Dimensions < 1) { throw new InvalidDataException(); } _books[i] = vorbisCodebook; } _bookBits = Utils.ilog(_books.Length); _barkMaps = new Dictionary <int, int[]>(); _barkMaps[_vorbis.Block0Size] = SynthesizeBarkCurve(_vorbis.Block0Size / 2); _barkMaps[_vorbis.Block1Size] = SynthesizeBarkCurve(_vorbis.Block1Size / 2); _wMap = new Dictionary <int, float[]>(); _wMap[_vorbis.Block0Size] = SynthesizeWDelMap(_vorbis.Block0Size / 2); _wMap[_vorbis.Block1Size] = SynthesizeWDelMap(_vorbis.Block1Size / 2); _reusablePacketData = new PacketData0[_vorbis._channels]; for (int j = 0; j < _reusablePacketData.Length; j++) { _reusablePacketData[j] = new PacketData0 { Coeff = new float[_order + 1] }; } }
internal static VorbisResidue Init(VorbisStreamDecoder vorbis, DataPacket packet) { int num = (int) packet.ReadBits(16); VorbisResidue vorbisResidue = (VorbisResidue) null; switch (num) { case 0: vorbisResidue = (VorbisResidue) new VorbisResidue.Residue0(vorbis); break; case 1: vorbisResidue = (VorbisResidue) new VorbisResidue.Residue1(vorbis); break; case 2: vorbisResidue = (VorbisResidue) new VorbisResidue.Residue2(vorbis); break; } if (vorbisResidue == null) throw new InvalidDataException(); vorbisResidue.Init(packet); return vorbisResidue; }
internal static VorbisResidue Init(VorbisStreamDecoder vorbis, DataPacket packet) { var type = (int)packet.ReadBits(16); VorbisResidue residue = null; switch (type) { case 0: residue = new Residue0(vorbis); break; case 1: residue = new Residue1(vorbis); break; case 2: residue = new Residue2(vorbis); break; } if (residue == null) { throw new InvalidDataException(); } residue.Init(packet); return(residue); }
internal static VorbisFloor Init(VorbisStreamDecoder vorbis, DataPacket packet) { int num = (int)packet.ReadBits(16); VorbisFloor vorbisFloor = (VorbisFloor)null; switch (num) { case 0: vorbisFloor = (VorbisFloor) new VorbisFloor.Floor0(vorbis); break; case 1: vorbisFloor = (VorbisFloor) new VorbisFloor.Floor1(vorbis); break; } if (vorbisFloor == null) { throw new InvalidDataException(); } vorbisFloor.Init(packet); return(vorbisFloor); }
internal int GetPacketLength(DataPacket curPacket, DataPacket lastPacket) { // if we don't have a previous packet, or we're re-syncing, this packet has no audio data to return if (lastPacket == null || curPacket.IsResync) { return(0); } // make sure they are audio packets if (curPacket.ReadBit()) { return(0); } if (lastPacket.ReadBit()) { return(0); } // get the current packet's information var modeIdx = (int)curPacket.ReadBits(_modeFieldBits); if (modeIdx < 0 || modeIdx >= Modes.Length) { return(0); } var mode = Modes[modeIdx]; // get the last packet's information modeIdx = (int)lastPacket.ReadBits(_modeFieldBits); if (modeIdx < 0 || modeIdx >= Modes.Length) { return(0); } var prevMode = Modes[modeIdx]; // now calculate the totals... return(mode.BlockSize / 4 + prevMode.BlockSize / 4); }
protected override void Init(DataPacket packet) { // this is pretty well stolen directly from libvorbis... BSD license _order = (int)packet.ReadBits(8); _rate = (int)packet.ReadBits(16); _bark_map_size = (int)packet.ReadBits(16); _ampBits = (int)packet.ReadBits(6); _ampOfs = (int)packet.ReadBits(8); _books = new VorbisCodebook[(int)packet.ReadBits(4) + 1]; if (_order < 1 || _rate < 1 || _bark_map_size < 1 || _books.Length == 0) throw new Exception(); _ampDiv = (1 << _ampBits) - 1; for (int i = 0; i < _books.Length; i++) { var num = (int)packet.ReadBits(8); if (num < 0 || num >= _vorbis.Books.Length) throw new Exception(); var book = _vorbis.Books[num]; if (book.MapType == 0 || book.Dimensions < 1) throw new Exception(); _books[i] = book; } _bookBits = Utils.ilog(_books.Length); _barkMaps = new Dictionary<int, int[]>(); _barkMaps[_vorbis.Block0Size] = SynthesizeBarkCurve(_vorbis.Block0Size / 2); _barkMaps[_vorbis.Block1Size] = SynthesizeBarkCurve(_vorbis.Block1Size / 2); _wMap = new Dictionary<int, float[]>(); _wMap[_vorbis.Block0Size] = SynthesizeWDelMap(_vorbis.Block0Size / 2); _wMap[_vorbis.Block1Size] = SynthesizeWDelMap(_vorbis.Block1Size / 2); _reusablePacketData = new PacketData0[_vorbis._channels]; for (int i = 0; i < _reusablePacketData.Length; i++) { _reusablePacketData[i] = new PacketData0() { Coeff = new float[_order + 1] }; } }
internal int GetPacketLength(DataPacket curPacket, DataPacket lastPacket) { if (lastPacket == null || curPacket.IsResync || (curPacket.ReadBit() || lastPacket.ReadBit())) { return(0); } int index1 = (int)curPacket.ReadBits(this._modeFieldBits); if (index1 < 0 || index1 >= this.Modes.Length) { return(0); } VorbisMode vorbisMode1 = this.Modes[index1]; int index2 = (int)lastPacket.ReadBits(this._modeFieldBits); if (index2 < 0 || index2 >= this.Modes.Length) { return(0); } VorbisMode vorbisMode2 = this.Modes[index2]; return(vorbisMode1.BlockSize / 4 + vorbisMode2.BlockSize / 4); }
protected override void Init(DataPacket packet) { // this is pretty well stolen directly from libvorbis... BSD license _begin = (int)packet.ReadBits(24); _end = (int)packet.ReadBits(24); _partitionSize = (int)packet.ReadBits(24) + 1; _classifications = (int)packet.ReadBits(6) + 1; _classBook = _vorbis.Books[(int)packet.ReadBits(8)]; _cascade = new int[_classifications]; var acc = 0; for (int i = 0; i < _classifications; i++) { var low_bits = (int)packet.ReadBits(3); if (packet.ReadBit()) { _cascade[i] = (int)packet.ReadBits(5) << 3 | low_bits; } else { _cascade[i] = low_bits; } acc += icount(_cascade[i]); } var bookNums = new int[acc]; for (var i = 0; i < acc; i++) { bookNums[i] = (int)packet.ReadBits(8); if (_vorbis.Books[bookNums[i]].MapType == 0) { throw new InvalidDataException(); } } var entries = _classBook.Entries; var dim = _classBook.Dimensions; var partvals = 1; while (dim > 0) { partvals *= _classifications; if (partvals > entries) { throw new InvalidDataException(); } --dim; } // now the lookups dim = _classBook.Dimensions; _books = new VorbisCodebook[_classifications][]; acc = 0; var maxstage = 0; int stages; for (int j = 0; j < _classifications; j++) { stages = Utils.ilog(_cascade[j]); _books[j] = new VorbisCodebook[stages]; if (stages > 0) { maxstage = Math.Max(maxstage, stages); for (int k = 0; k < stages; k++) { if ((_cascade[j] & (1 << k)) > 0) { _books[j][k] = _vorbis.Books[bookNums[acc++]]; } } } } _maxStages = maxstage; _decodeMap = new int[partvals][]; for (int j = 0; j < partvals; j++) { var val = j; var mult = partvals / _classifications; _decodeMap[j] = new int[_classBook.Dimensions]; for (int k = 0; k < _classBook.Dimensions; k++) { var deco = val / mult; val -= deco * mult; mult /= _classifications; _decodeMap[j][k] = deco; } } _entryCache = new int[_partitionSize]; _partWordCache = new int[_vorbis._channels][][]; var maxPartWords = ((_end - _begin) / _partitionSize + _classBook.Dimensions - 1) / _classBook.Dimensions; for (int ch = 0; ch < _vorbis._channels; ch++) { _partWordCache[ch] = new int[maxPartWords][]; } }
void LoadBooks(DataPacket packet) { packet.SkipBits(8); if (!packet.ReadBytes(6).SequenceEqual(new byte[] { 0x76, 0x6f, 0x72, 0x62, 0x69, 0x73 })) { throw new InvalidDataException("Corrupted book header!"); } var bits = packet.BitsRead; _glueBits += packet.BitsRead; // get books Books = new VorbisCodebook[packet.ReadByte() + 1]; for (int i = 0; i < Books.Length; i++) { Books[i] = VorbisCodebook.Init(this, packet, i); } _bookBits += packet.BitsRead - bits; bits = packet.BitsRead; // get times Times = new VorbisTime[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Times.Length; i++) { Times[i] = VorbisTime.Init(this, packet); } _timeHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get floor Floors = new VorbisFloor[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Floors.Length; i++) { Floors[i] = VorbisFloor.Init(this, packet); } _floorHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get residue Residues = new VorbisResidue[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Residues.Length; i++) { Residues[i] = VorbisResidue.Init(this, packet); } _resHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get map Maps = new VorbisMapping[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Maps.Length; i++) { Maps[i] = VorbisMapping.Init(this, packet); } _mapHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get mode settings Modes = new VorbisMode[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Modes.Length; i++) { Modes[i] = VorbisMode.Init(this, packet); } _modeHdrBits += packet.BitsRead - bits; // check the framing bit if (!packet.ReadBit()) { throw new InvalidDataException(); } ++_glueBits; _wasteHdrBits += 8 * packet.Length - packet.BitsRead; _modeFieldBits = Utils.ilog(Modes.Length - 1); }
protected override void Init(DataPacket packet) { _partitionClass = new int[(int)packet.ReadBits(5)]; for (int i = 0; i < _partitionClass.Length; i++) { _partitionClass[i] = (int)packet.ReadBits(4); } var maximum_class = _partitionClass.Max(); _classDimensions = new int[maximum_class + 1]; _classSubclasses = new int[maximum_class + 1]; _classMasterbooks = new VorbisCodebook[maximum_class + 1]; _classMasterBookIndex = new int[maximum_class + 1]; _subclassBooks = new VorbisCodebook[maximum_class + 1][]; _subclassBookIndex = new int[maximum_class + 1][]; for (int i = 0; i <= maximum_class; i++) { _classDimensions[i] = (int)packet.ReadBits(3) + 1; _classSubclasses[i] = (int)packet.ReadBits(2); if (_classSubclasses[i] > 0) { _classMasterBookIndex[i] = (int)packet.ReadBits(8); _classMasterbooks[i] = _vorbis.Books[_classMasterBookIndex[i]]; } _subclassBooks[i] = new VorbisCodebook[1 << _classSubclasses[i]]; _subclassBookIndex[i] = new int[_subclassBooks[i].Length]; for (int j = 0; j < _subclassBooks[i].Length; j++) { var bookNum = (int)packet.ReadBits(8) - 1; if (bookNum >= 0) _subclassBooks[i][j] = _vorbis.Books[bookNum]; _subclassBookIndex[i][j] = bookNum; } } _multiplier = (int)packet.ReadBits(2); _range = _rangeLookup[_multiplier]; _yBits = _yBitsLookup[_multiplier]; ++_multiplier; var rangeBits = (int)packet.ReadBits(4); var xList = new List<int>(); xList.Add(0); xList.Add(1 << rangeBits); for (int i = 0; i < _partitionClass.Length; i++) { var classNum = _partitionClass[i]; for (int j = 0; j < _classDimensions[classNum]; j++) { xList.Add((int)packet.ReadBits(rangeBits)); } } _xList = xList.ToArray(); // precalc the low and high neighbors (and init the sort table) _lNeigh = new int[xList.Count]; _hNeigh = new int[xList.Count]; _sortIdx = new int[xList.Count]; _sortIdx[0] = 0; _sortIdx[1] = 1; for (int i = 2; i < _lNeigh.Length; i++) { _lNeigh[i] = 0; _hNeigh[i] = 1; _sortIdx[i] = i; for (int j = 2; j < i; j++) { var temp = _xList[j]; if (temp < _xList[i]) { if (temp > _xList[_lNeigh[i]]) _lNeigh[i] = j; } else { if (temp < _xList[_hNeigh[i]]) _hNeigh[i] = j; } } } // precalc the sort table for (int i = 0; i < _sortIdx.Length - 1; i++) { for (int j = i + 1; j < _sortIdx.Length; j++) { if (_xList[i] == _xList[j]) throw new InvalidDataException(); if (_xList[_sortIdx[i]] > _xList[_sortIdx[j]]) { // swap the sort indexes var temp = _sortIdx[i]; _sortIdx[i] = _sortIdx[j]; _sortIdx[j] = temp; } } } }
private void ProcessStreamHeader(DataPacket packet) { this._pagesSeen.Add(packet.PageSequenceNumber); long bitsRead = packet.BitsRead; if (packet.ReadInt32() != 0) throw new InvalidDataException("Only Vorbis stream version 0 is supported."); this._channels = (int) packet.ReadByte(); this._sampleRate = packet.ReadInt32(); this._upperBitrate = packet.ReadInt32(); this._nominalBitrate = packet.ReadInt32(); this._lowerBitrate = packet.ReadInt32(); this.Block0Size = 1 << (int) packet.ReadBits(4); this.Block1Size = 1 << (int) packet.ReadBits(4); if (this._nominalBitrate == 0 && this._upperBitrate > 0 && this._lowerBitrate > 0) this._nominalBitrate = (this._upperBitrate + this._lowerBitrate) / 2; this._metaBits += packet.BitsRead - bitsRead + 8L; this._wasteHdrBits += (long) (8 * packet.Length) - packet.BitsRead; }
bool UnpackPacket(DataPacket packet) { // make sure we're on an audio packet if (packet.ReadBit()) { // we really can't do anything... count the bits as waste return false; } // get mode and prev/next flags var modeBits = _modeFieldBits; _mode = Modes[(int)packet.ReadBits(_modeFieldBits)]; if (_mode.BlockFlag) { _prevFlag = packet.ReadBit(); _nextFlag = packet.ReadBit(); modeBits += 2; } else { _prevFlag = _nextFlag = false; } if (packet.IsShort) return false; var startBits = packet.BitsRead; var halfBlockSize = _mode.BlockSize / 2; // read the noise floor data (but don't decode yet) for (int i = 0; i < _channels; i++) { _floorData[i] = _mode.Mapping.ChannelSubmap[i].Floor.UnpackPacket(packet, _mode.BlockSize, i); _noExecuteChannel[i] = !_floorData[i].ExecuteChannel; // go ahead and clear the residue buffers Array.Clear(_residue[i], 0, halfBlockSize); } // make sure we handle no-energy channels correctly given the couplings... foreach (var step in _mode.Mapping.CouplingSteps) { if (_floorData[step.Angle].ExecuteChannel || _floorData[step.Magnitude].ExecuteChannel) { _floorData[step.Angle].ForceEnergy = true; _floorData[step.Magnitude].ForceEnergy = true; } } var floorBits = packet.BitsRead - startBits; startBits = packet.BitsRead; foreach (var subMap in _mode.Mapping.Submaps) { for (int j = 0; j < _channels; j++) { if (_mode.Mapping.ChannelSubmap[j] != subMap) { _floorData[j].ForceNoEnergy = true; } } var rTemp = subMap.Residue.Decode(packet, _noExecuteChannel, _channels, _mode.BlockSize); for (int c = 0; c < _channels; c++) { var r = _residue[c]; var rt = rTemp[c]; for (int i = 0; i < halfBlockSize; i++) { r[i] += rt[i]; } } } _glueBits += 1; _modeBits += modeBits; _floorBits += floorBits; _resBits += packet.BitsRead - startBits; _wasteBits += 8 * packet.Length - packet.BitsRead; _packetCount += 1; return true; }
protected override void Init(DataPacket packet) { this._partitionClass = new int[(int)packet.ReadBits(5)]; for (int index = 0; index < this._partitionClass.Length; ++index) { this._partitionClass[index] = (int)packet.ReadBits(4); } int num1 = Enumerable.Max((IEnumerable <int>) this._partitionClass); this._classDimensions = new int[num1 + 1]; this._classSubclasses = new int[num1 + 1]; this._classMasterbooks = new VorbisCodebook[num1 + 1]; this._classMasterBookIndex = new int[num1 + 1]; this._subclassBooks = new VorbisCodebook[num1 + 1][]; this._subclassBookIndex = new int[num1 + 1][]; for (int index1 = 0; index1 <= num1; ++index1) { this._classDimensions[index1] = (int)packet.ReadBits(3) + 1; this._classSubclasses[index1] = (int)packet.ReadBits(2); if (this._classSubclasses[index1] > 0) { this._classMasterBookIndex[index1] = (int)packet.ReadBits(8); this._classMasterbooks[index1] = this._vorbis.Books[this._classMasterBookIndex[index1]]; } this._subclassBooks[index1] = new VorbisCodebook[1 << this._classSubclasses[index1]]; this._subclassBookIndex[index1] = new int[this._subclassBooks[index1].Length]; for (int index2 = 0; index2 < this._subclassBooks[index1].Length; ++index2) { int index3 = (int)packet.ReadBits(8) - 1; if (index3 >= 0) { this._subclassBooks[index1][index2] = this._vorbis.Books[index3]; } this._subclassBookIndex[index1][index2] = index3; } } this._multiplier = (int)packet.ReadBits(2); this._range = VorbisFloor.Floor1._rangeLookup[this._multiplier]; this._yBits = VorbisFloor.Floor1._yBitsLookup[this._multiplier]; ++this._multiplier; int count = (int)packet.ReadBits(4); List <int> list = new List <int>(); list.Add(0); list.Add(1 << count); for (int index1 = 0; index1 < this._partitionClass.Length; ++index1) { int index2 = this._partitionClass[index1]; for (int index3 = 0; index3 < this._classDimensions[index2]; ++index3) { list.Add((int)packet.ReadBits(count)); } } this._xList = list.ToArray(); this._lNeigh = new int[list.Count]; this._hNeigh = new int[list.Count]; this._sortIdx = new int[list.Count]; this._sortIdx[0] = 0; this._sortIdx[1] = 1; for (int index1 = 2; index1 < this._lNeigh.Length; ++index1) { this._lNeigh[index1] = 0; this._hNeigh[index1] = 1; this._sortIdx[index1] = index1; for (int index2 = 2; index2 < index1; ++index2) { int num2 = this._xList[index2]; if (num2 < this._xList[index1]) { if (num2 > this._xList[this._lNeigh[index1]]) { this._lNeigh[index1] = index2; } } else if (num2 < this._xList[this._hNeigh[index1]]) { this._hNeigh[index1] = index2; } } } for (int index1 = 0; index1 < this._sortIdx.Length - 1; ++index1) { for (int index2 = index1 + 1; index2 < this._sortIdx.Length; ++index2) { if (this._xList[index1] == this._xList[index2]) { throw new InvalidDataException(); } if (this._xList[this._sortIdx[index1]] > this._xList[this._sortIdx[index2]]) { int num2 = this._sortIdx[index1]; this._sortIdx[index1] = this._sortIdx[index2]; this._sortIdx[index2] = num2; } } } }
public void InitLookupTable(DataPacket packet) { MapType = (int)packet.ReadBits(4); if (MapType == 0) { return; } float num = Utils.ConvertFromVorbisFloat32(packet.ReadUInt32()); float num2 = Utils.ConvertFromVorbisFloat32(packet.ReadUInt32()); int count = (int)packet.ReadBits(4) + 1; bool flag = packet.ReadBit(); int num3 = Entries * Dimensions; float[] array = new float[num3]; if (MapType == 1) { num3 = lookup1_values(); } uint[] array2 = new uint[num3]; for (int i = 0; i < num3; i++) { array2[i] = (uint)packet.ReadBits(count); } if (MapType == 1) { for (int j = 0; j < Entries; j++) { double num4 = 0.0; int num5 = 1; for (int k = 0; k < Dimensions; k++) { int num6 = j / num5 % num3; double num7 = (double)((float)(double)array2[num6] * num2 + num) + num4; array[j * Dimensions + k] = (float)num7; if (flag) { num4 = num7; } num5 *= num3; } } } else { for (int l = 0; l < Entries; l++) { double num8 = 0.0; int num9 = l * Dimensions; for (int m = 0; m < Dimensions; m++) { double num10 = (double)((float)(double)array2[num9] * num2 + num) + num8; array[l * Dimensions + m] = (float)num10; if (flag) { num8 = num10; } num9++; } } } LookupTable = array; }
protected override void Init(DataPacket packet) { var submapCount = 1; if (packet.ReadBit()) { submapCount += (int)packet.ReadBits(4); } // square polar mapping var couplingSteps = 0; if (packet.ReadBit()) { couplingSteps = (int)packet.ReadBits(8) + 1; } var couplingBits = Utils.ilog(_vorbis._channels - 1); CouplingSteps = new CouplingStep[couplingSteps]; for (int j = 0; j < couplingSteps; j++) { var magnitude = (int)packet.ReadBits(couplingBits); var angle = (int)packet.ReadBits(couplingBits); if (magnitude == angle || magnitude > _vorbis._channels - 1 || angle > _vorbis._channels - 1) { throw new InvalidDataException(); } CouplingSteps[j] = new CouplingStep { Angle = angle, Magnitude = magnitude }; } // reserved bits if (packet.ReadBits(2) != 0UL) { throw new InvalidDataException(); } // channel multiplex var mux = new int[_vorbis._channels]; if (submapCount > 1) { for (int c = 0; c < ChannelSubmap.Length; c++) { mux[c] = (int)packet.ReadBits(4); if (mux[c] >= submapCount) { throw new InvalidDataException(); } } } // submaps Submaps = new Submap[submapCount]; for (int j = 0; j < submapCount; j++) { packet.ReadBits(8); // unused placeholder var floorNum = (int)packet.ReadBits(8); if (floorNum >= _vorbis.Floors.Length) { throw new InvalidDataException(); } var residueNum = (int)packet.ReadBits(8); if (residueNum >= _vorbis.Residues.Length) { throw new InvalidDataException(); } Submaps[j] = new Submap { Floor = _vorbis.Floors[floorNum], Residue = _vorbis.Residues[floorNum] }; } ChannelSubmap = new Submap[_vorbis._channels]; for (int c = 0; c < ChannelSubmap.Length; c++) { ChannelSubmap[c] = Submaps[mux[c]]; } }
void InitTree(DataPacket packet) { bool sparse; int total = 0; if (packet.ReadBit()) { // ordered var len = (int)packet.ReadBits(5) + 1; for (var i = 0; i < Entries;) { var cnt = (int)packet.ReadBits(Utils.ilog(Entries - i)); while (--cnt >= 0) { Lengths[i++] = len; } ++len; } total = 0; sparse = false; } else { // unordered sparse = packet.ReadBit(); for (var i = 0; i < Entries; i++) { if (!sparse || packet.ReadBit()) { Lengths[i] = (int)packet.ReadBits(5) + 1; ++total; } else { // mark the entry as unused Lengths[i] = -1; } } } // figure out the maximum bit size; if all are unused, don't do anything else if ((MaxBits = Lengths.Max()) > -1) { int sortedCount = 0; int[] codewordLengths = null; if (sparse && total >= Entries >> 2) { codewordLengths = new int[Entries]; Array.Copy(Lengths, codewordLengths, Entries); sparse = false; } // compute size of sorted tables if (sparse) { sortedCount = total; } else { sortedCount = 0; } int sortedEntries = sortedCount; int[] values = null; int[] codewords = null; if (!sparse) { codewords = new int[Entries]; } else if (sortedEntries != 0) { codewordLengths = new int[sortedEntries]; codewords = new int[sortedEntries]; values = new int[sortedEntries]; } if (!ComputeCodewords(sparse, sortedEntries, codewords, codewordLengths, len: Lengths, n: Entries, values: values)) { throw new InvalidDataException(); } PrefixList = Huffman.BuildPrefixedLinkedList(values ?? Enumerable.Range(0, codewords.Length).ToArray(), codewordLengths ?? Lengths, codewords, out PrefixBitLength, out PrefixOverflowTree); } }
public override void Init(DataPacket packet) { int num = 1; if (packet.ReadBit()) { num += (int)packet.ReadBits(4); } int num2 = 0; if (packet.ReadBit()) { num2 = (int)packet.ReadBits(8) + 1; } int count = Utils.ilog(_vorbis._channels - 1); CouplingSteps = new CouplingStep[num2]; for (int i = 0; i < num2; i++) { int num3 = (int)packet.ReadBits(count); int num4 = (int)packet.ReadBits(count); if (num3 == num4 || num3 > _vorbis._channels - 1 || num4 > _vorbis._channels - 1) { throw new InvalidDataException(); } CouplingSteps[i] = new CouplingStep { Angle = num4, Magnitude = num3 }; } if (packet.ReadBits(2) != 0L) { throw new InvalidDataException(); } int[] array = new int[_vorbis._channels]; if (num > 1) { for (int j = 0; j < ChannelSubmap.Length; j++) { array[j] = (int)packet.ReadBits(4); if (array[j] >= num) { throw new InvalidDataException(); } } } Submaps = new Submap[num]; for (int k = 0; k < num; k++) { packet.ReadBits(8); int num5 = (int)packet.ReadBits(8); if (num5 >= _vorbis.Floors.Length) { throw new InvalidDataException(); } if ((int)packet.ReadBits(8) >= _vorbis.Residues.Length) { throw new InvalidDataException(); } Submaps[k] = new Submap { Floor = _vorbis.Floors[num5], Residue = _vorbis.Residues[num5] }; } ChannelSubmap = new Submap[_vorbis._channels]; for (int l = 0; l < ChannelSubmap.Length; l++) { ChannelSubmap[l] = Submaps[array[l]]; } }
private void InitLookupTable(DataPacket packet) { this.MapType = (int)packet.ReadBits(4); if (this.MapType == 0) { return; } float num1 = Utils.ConvertFromVorbisFloat32(packet.ReadUInt32()); float num2 = Utils.ConvertFromVorbisFloat32(packet.ReadUInt32()); int count = (int)packet.ReadBits(4) + 1; bool flag = packet.ReadBit(); int length = this.Entries * this.Dimensions; float[] numArray1 = new float[length]; if (this.MapType == 1) { length = this.lookup1_values(); } uint[] numArray2 = new uint[length]; for (int index = 0; index < length; ++index) { numArray2[index] = (uint)packet.ReadBits(count); } if (this.MapType == 1) { for (int index1 = 0; index1 < this.Entries; ++index1) { double num3 = 0.0; int num4 = 1; for (int index2 = 0; index2 < this.Dimensions; ++index2) { int index3 = index1 / num4 % length; double num5 = (double)numArray2[index3] * (double)num2 + (double)num1 + num3; numArray1[index1 * this.Dimensions + index2] = (float)num5; if (flag) { num3 = num5; } num4 *= length; } } } else { for (int index1 = 0; index1 < this.Entries; ++index1) { double num3 = 0.0; int index2 = index1 * this.Dimensions; for (int index3 = 0; index3 < this.Dimensions; ++index3) { double num4 = (double)numArray2[index2] * (double)num2 + (double)num1 + num3; numArray1[index1 * this.Dimensions + index3] = (float)num4; if (flag) { num3 = num4; } ++index2; } } } this.LookupTable = numArray1; }
internal int GetPacketLength(DataPacket curPacket, DataPacket lastPacket) { if (lastPacket == null || curPacket.IsResync || (curPacket.ReadBit() || lastPacket.ReadBit())) return 0; int index1 = (int) curPacket.ReadBits(this._modeFieldBits); if (index1 < 0 || index1 >= this.Modes.Length) return 0; VorbisMode vorbisMode1 = this.Modes[index1]; int index2 = (int) lastPacket.ReadBits(this._modeFieldBits); if (index2 < 0 || index2 >= this.Modes.Length) return 0; VorbisMode vorbisMode2 = this.Modes[index2]; return vorbisMode1.BlockSize / 4 + vorbisMode2.BlockSize / 4; }
private VorbisStreamDecoder.PacketDecodeInfo UnpackPacket(DataPacket packet) { if (packet.ReadBit()) return (VorbisStreamDecoder.PacketDecodeInfo) null; VorbisStreamDecoder.PacketDecodeInfo packetDecodeInfo = new VorbisStreamDecoder.PacketDecodeInfo(); int num1 = this._modeFieldBits; try { packetDecodeInfo.Mode = this.Modes[(int) packet.ReadBits(this._modeFieldBits)]; if (packetDecodeInfo.Mode.BlockFlag) { packetDecodeInfo.PrevFlag = packet.ReadBit(); packetDecodeInfo.NextFlag = packet.ReadBit(); num1 += 2; } } catch (EndOfStreamException ex) { return (VorbisStreamDecoder.PacketDecodeInfo) null; } try { long bitsRead1 = packet.BitsRead; packetDecodeInfo.FloorData = ACache.Get<VorbisFloor.PacketData>(this._channels); bool[] buffer1 = ACache.Get<bool>(this._channels); for (int index = 0; index < this._channels; ++index) { packetDecodeInfo.FloorData[index] = packetDecodeInfo.Mode.Mapping.ChannelSubmap[index].Floor.UnpackPacket(packet, packetDecodeInfo.Mode.BlockSize); buffer1[index] = !packetDecodeInfo.FloorData[index].ExecuteChannel; } foreach (VorbisMapping.CouplingStep couplingStep in packetDecodeInfo.Mode.Mapping.CouplingSteps) { if (packetDecodeInfo.FloorData[couplingStep.Angle].ExecuteChannel || packetDecodeInfo.FloorData[couplingStep.Magnitude].ExecuteChannel) { packetDecodeInfo.FloorData[couplingStep.Angle].ForceEnergy = true; packetDecodeInfo.FloorData[couplingStep.Magnitude].ForceEnergy = true; } } long num2 = packet.BitsRead - bitsRead1; long bitsRead2 = packet.BitsRead; packetDecodeInfo.Residue = ACache.Get<float>(this._channels, packetDecodeInfo.Mode.BlockSize); foreach (VorbisMapping.Submap submap in packetDecodeInfo.Mode.Mapping.Submaps) { for (int index = 0; index < this._channels; ++index) { if (packetDecodeInfo.Mode.Mapping.ChannelSubmap[index] != submap) packetDecodeInfo.FloorData[index].ForceNoEnergy = true; } float[][] buffer2 = submap.Residue.Decode(packet, buffer1, this._channels, packetDecodeInfo.Mode.BlockSize); for (int index1 = 0; index1 < this._channels; ++index1) { float[] numArray1 = packetDecodeInfo.Residue[index1]; float[] numArray2 = buffer2[index1]; for (int index2 = 0; index2 < packetDecodeInfo.Mode.BlockSize; ++index2) numArray1[index2] += numArray2[index2]; } ACache.Return<float>(ref buffer2); } ACache.Return<bool>(ref buffer1); ++this._glueBits; this._modeBits += (long) num1; this._floorBits += num2; this._resBits += packet.BitsRead - bitsRead2; this._wasteBits += (long) (8 * packet.Length) - packet.BitsRead; ++this._packetCount; } catch (EndOfStreamException ex) { this.ResetDecoder(); packetDecodeInfo = (VorbisStreamDecoder.PacketDecodeInfo) null; } catch (InvalidDataException ex) { packetDecodeInfo = (VorbisStreamDecoder.PacketDecodeInfo) null; } packet.Done(); return packetDecodeInfo; }
private void LoadBooks(DataPacket packet) { packet.SkipBits(8); if (!Enumerable.SequenceEqual<byte>((IEnumerable<byte>) packet.ReadBytes(6), (IEnumerable<byte>) new byte[6] { (byte) 118, (byte) 111, (byte) 114, (byte) 98, (byte) 105, (byte) 115 })) throw new InvalidDataException("Corrupted book header!"); long bitsRead1 = packet.BitsRead; this._glueBits += packet.BitsRead; this.Books = new VorbisCodebook[(int) packet.ReadByte() + 1]; for (int number = 0; number < this.Books.Length; ++number) this.Books[number] = VorbisCodebook.Init(this, packet, number); this._bookBits += packet.BitsRead - bitsRead1; long bitsRead2 = packet.BitsRead; this.Times = new VorbisTime[(int) packet.ReadBits(6) + 1]; for (int index = 0; index < this.Times.Length; ++index) this.Times[index] = VorbisTime.Init(this, packet); this._timeHdrBits += packet.BitsRead - bitsRead2; long bitsRead3 = packet.BitsRead; this.Floors = new VorbisFloor[(int) packet.ReadBits(6) + 1]; for (int index = 0; index < this.Floors.Length; ++index) this.Floors[index] = VorbisFloor.Init(this, packet); this._floorHdrBits += packet.BitsRead - bitsRead3; long bitsRead4 = packet.BitsRead; this.Residues = new VorbisResidue[(int) packet.ReadBits(6) + 1]; for (int index = 0; index < this.Residues.Length; ++index) this.Residues[index] = VorbisResidue.Init(this, packet); this._resHdrBits += packet.BitsRead - bitsRead4; long bitsRead5 = packet.BitsRead; this.Maps = new VorbisMapping[(int) packet.ReadBits(6) + 1]; for (int index = 0; index < this.Maps.Length; ++index) this.Maps[index] = VorbisMapping.Init(this, packet); this._mapHdrBits += packet.BitsRead - bitsRead5; long bitsRead6 = packet.BitsRead; this.Modes = new VorbisMode[(int) packet.ReadBits(6) + 1]; for (int index = 0; index < this.Modes.Length; ++index) this.Modes[index] = VorbisMode.Init(this, packet); this._modeHdrBits += packet.BitsRead - bitsRead6; if (!packet.ReadBit()) throw new InvalidDataException(); ++this._glueBits; this._wasteHdrBits += (long) (8 * packet.Length) - packet.BitsRead; this._modeFieldBits = Utils.ilog(this.Modes.Length - 1); }
internal override PacketData UnpackPacket(DataPacket packet, int blockSize, int channel) { var data = _reusablePacketData[channel]; data.BlockSize = blockSize; data.ForceEnergy = false; data.ForceNoEnergy = false; data.PostCount = 0; Array.Clear(data.Posts, 0, 64); // hoist ReadPosts to here since that's all we're doing... if (packet.ReadBit()) { var postCount = 2; data.Posts[0] = (int)packet.ReadBits(_yBits); data.Posts[1] = (int)packet.ReadBits(_yBits); for (int i = 0; i < _partitionClass.Length; i++) { var clsNum = _partitionClass[i]; var cdim = _classDimensions[clsNum]; var cbits = _classSubclasses[clsNum]; var csub = (1 << cbits) - 1; var cval = 0U; if (cbits > 0) { if ((cval = (uint)_classMasterbooks[clsNum].DecodeScalar(packet)) == uint.MaxValue) { // we read a bad value... bail postCount = 0; break; } } for (int j = 0; j < cdim; j++) { var book = _subclassBooks[clsNum][cval & csub]; cval >>= cbits; if (book != null) { if ((data.Posts[postCount] = book.DecodeScalar(packet)) == -1) { // we read a bad value... bail postCount = 0; i = _partitionClass.Length; break; } } ++postCount; } } data.PostCount = postCount; } return data; }
public void InitTree(DataPacket packet) { int num = 0; bool flag; if (packet.ReadBit()) { int num2 = (int)packet.ReadBits(5) + 1; int num3 = 0; while (num3 < Entries) { int num4 = (int)packet.ReadBits(Utils.ilog(Entries - num3)); while (--num4 >= 0) { Lengths[num3++] = num2; } num2++; } num = 0; flag = false; } else { flag = packet.ReadBit(); for (int i = 0; i < Entries; i++) { if (!flag || packet.ReadBit()) { Lengths[i] = (int)packet.ReadBits(5) + 1; num++; } else { Lengths[i] = -1; } } } MaxBits = Lengths.Max(); int num5 = 0; int[] array = null; if (flag && num >= Entries >> 2) { array = new int[Entries]; Array.Copy(Lengths, array, Entries); flag = false; } num5 = (flag ? num : 0); int num6 = num5; int[] array2 = null; int[] array3 = null; if (!flag) { array3 = new int[Entries]; } else if (num6 != 0) { array = new int[num6]; array3 = new int[num6]; array2 = new int[num6]; } if (!ComputeCodewords(flag, num6, array3, array, Lengths, Entries, array2)) { throw new InvalidDataException(); } PrefixList = Huffman.BuildPrefixedLinkedList(array2 ?? Enumerable.Range(0, array3.Length).ToArray(), array ?? Lengths, array3, out PrefixBitLength, out PrefixOverflowTree); }
bool UnpackPacket(DataPacket packet) { // make sure we're on an audio packet if (packet.ReadBit()) { // we really can't do anything... count the bits as waste return(false); } // get mode and prev/next flags var modeBits = _modeFieldBits; _mode = Modes[(int)packet.ReadBits(_modeFieldBits)]; if (_mode.BlockFlag) { _prevFlag = packet.ReadBit(); _nextFlag = packet.ReadBit(); modeBits += 2; } else { _prevFlag = _nextFlag = false; } if (packet.IsShort) { return(false); } var startBits = packet.BitsRead; var halfBlockSize = _mode.BlockSize / 2; // read the noise floor data (but don't decode yet) for (int i = 0; i < _channels; i++) { _floorData[i] = _mode.Mapping.ChannelSubmap[i].Floor.UnpackPacket(packet, _mode.BlockSize, i); _noExecuteChannel[i] = !_floorData[i].ExecuteChannel; // go ahead and clear the residue buffers Array.Clear(_residue[i], 0, halfBlockSize); } // make sure we handle no-energy channels correctly given the couplings... foreach (var step in _mode.Mapping.CouplingSteps) { if (_floorData[step.Angle].ExecuteChannel || _floorData[step.Magnitude].ExecuteChannel) { _floorData[step.Angle].ForceEnergy = true; _floorData[step.Magnitude].ForceEnergy = true; } } var floorBits = packet.BitsRead - startBits; startBits = packet.BitsRead; foreach (var subMap in _mode.Mapping.Submaps) { for (int j = 0; j < _channels; j++) { if (_mode.Mapping.ChannelSubmap[j] != subMap) { _floorData[j].ForceNoEnergy = true; } } var rTemp = subMap.Residue.Decode(packet, _noExecuteChannel, _channels, _mode.BlockSize); for (int c = 0; c < _channels; c++) { var r = _residue[c]; var rt = rTemp[c]; for (int i = 0; i < halfBlockSize; i++) { r[i] += rt[i]; } } } _glueBits += 1; _modeBits += modeBits; _floorBits += floorBits; _resBits += packet.BitsRead - startBits; _wasteBits += 8 * packet.Length - packet.BitsRead; _packetCount += 1; return(true); }
protected override void Init(DataPacket packet) { _partitionClass = new int[(int)packet.ReadBits(5)]; for (int i = 0; i < _partitionClass.Length; i++) { _partitionClass[i] = (int)packet.ReadBits(4); } var maximum_class = _partitionClass.Max(); _classDimensions = new int[maximum_class + 1]; _classSubclasses = new int[maximum_class + 1]; _classMasterbooks = new VorbisCodebook[maximum_class + 1]; _classMasterBookIndex = new int[maximum_class + 1]; _subclassBooks = new VorbisCodebook[maximum_class + 1][]; _subclassBookIndex = new int[maximum_class + 1][]; for (int i = 0; i <= maximum_class; i++) { _classDimensions[i] = (int)packet.ReadBits(3) + 1; _classSubclasses[i] = (int)packet.ReadBits(2); if (_classSubclasses[i] > 0) { _classMasterBookIndex[i] = (int)packet.ReadBits(8); _classMasterbooks[i] = _vorbis.Books[_classMasterBookIndex[i]]; } _subclassBooks[i] = new VorbisCodebook[1 << _classSubclasses[i]]; _subclassBookIndex[i] = new int[_subclassBooks[i].Length]; for (int j = 0; j < _subclassBooks[i].Length; j++) { var bookNum = (int)packet.ReadBits(8) - 1; if (bookNum >= 0) { _subclassBooks[i][j] = _vorbis.Books[bookNum]; } _subclassBookIndex[i][j] = bookNum; } } _multiplier = (int)packet.ReadBits(2); _range = _rangeLookup[_multiplier]; _yBits = _yBitsLookup[_multiplier]; ++_multiplier; var rangeBits = (int)packet.ReadBits(4); var xList = new List <int>(); xList.Add(0); xList.Add(1 << rangeBits); for (int i = 0; i < _partitionClass.Length; i++) { var classNum = _partitionClass[i]; for (int j = 0; j < _classDimensions[classNum]; j++) { xList.Add((int)packet.ReadBits(rangeBits)); } } _xList = xList.ToArray(); // precalc the low and high neighbors (and init the sort table) _lNeigh = new int[xList.Count]; _hNeigh = new int[xList.Count]; _sortIdx = new int[xList.Count]; _sortIdx[0] = 0; _sortIdx[1] = 1; for (int i = 2; i < _lNeigh.Length; i++) { _lNeigh[i] = 0; _hNeigh[i] = 1; _sortIdx[i] = i; for (int j = 2; j < i; j++) { var temp = _xList[j]; if (temp < _xList[i]) { if (temp > _xList[_lNeigh[i]]) { _lNeigh[i] = j; } } else { if (temp < _xList[_hNeigh[i]]) { _hNeigh[i] = j; } } } } // precalc the sort table for (int i = 0; i < _sortIdx.Length - 1; i++) { for (int j = i + 1; j < _sortIdx.Length; j++) { if (_xList[i] == _xList[j]) { throw new InvalidDataException(); } if (_xList[_sortIdx[i]] > _xList[_sortIdx[j]]) { // swap the sort indexes var temp = _sortIdx[i]; _sortIdx[i] = _sortIdx[j]; _sortIdx[j] = temp; } } } // pre-create our packet data instances _reusablePacketData = new PacketData1[_vorbis._channels]; for (int i = 0; i < _reusablePacketData.Length; i++) { _reusablePacketData[i] = new PacketData1(); } }
void ProcessStreamHeader(DataPacket packet) { _pagesSeen.Add(packet.PageSequenceNumber); var startPos = packet.BitsRead; if (packet.ReadInt32() != 0) throw new ArgumentException("Only Vorbis stream version 0 is supported."); _channels = packet.ReadByte(); _sampleRate = packet.ReadInt32(); _upperBitrate = packet.ReadInt32(); _nominalBitrate = packet.ReadInt32(); _lowerBitrate = packet.ReadInt32(); Block0Size = 1 << (int)packet.ReadBits(4); Block1Size = 1 << (int)packet.ReadBits(4); if (_nominalBitrate == 0) { if (_upperBitrate > 0 && _lowerBitrate > 0) { _nominalBitrate = (_upperBitrate + _lowerBitrate) / 2; } } _metaBits += packet.BitsRead - startPos + 8; _wasteHdrBits += 8 * packet.Length - packet.BitsRead; }
internal int GetPacketLength(DataPacket curPacket, DataPacket lastPacket) { // if we don't have a previous packet, or we're re-syncing, this packet has no audio data to return if (lastPacket == null || curPacket.IsResync) return 0; // make sure they are audio packets if (curPacket.ReadBit()) return 0; if (lastPacket.ReadBit()) return 0; // get the current packet's information var modeIdx = (int)curPacket.ReadBits(_modeFieldBits); if (modeIdx < 0 || modeIdx >= Modes.Length) return 0; var mode = Modes[modeIdx]; // get the last packet's information modeIdx = (int)lastPacket.ReadBits(_modeFieldBits); if (modeIdx < 0 || modeIdx >= Modes.Length) return 0; var prevMode = Modes[modeIdx]; // now calculate the totals... return mode.BlockSize / 4 + prevMode.BlockSize / 4; }
internal override PacketData UnpackPacket(DataPacket packet, int blockSize) { var data = new PacketData1 { BlockSize = blockSize }; // hoist ReadPosts to here since that's all we're doing... if (packet.ReadBit()) { try { var postCount = 2; var posts = ACache.Get<int>(64); posts[0] = (int)packet.ReadBits(_yBits); posts[1] = (int)packet.ReadBits(_yBits); for (int i = 0; i < _partitionClass.Length; i++) { var clsNum = _partitionClass[i]; var cdim = _classDimensions[clsNum]; var cbits = _classSubclasses[clsNum]; var csub = (1 << cbits) - 1; var cval = 0U; if (cbits > 0) { cval = (uint)_classMasterbooks[clsNum].DecodeScalar(packet); } for (int j = 0; j < cdim; j++) { var book = _subclassBooks[clsNum][cval & csub]; cval >>= cbits; if (book != null) { posts[postCount] = (int)book.DecodeScalar(packet); } ++postCount; } } data.Posts = posts; data.PostCount = postCount; } catch (EndOfStreamException) { } } return data; }
internal override PacketData UnpackPacket(DataPacket packet, int blockSize) { var data = new PacketData0 { BlockSize = blockSize }; data.Amp = packet.ReadBits(_ampBits); if (data.Amp > 0f) { try { var coefficients = new List<float>(); var bookNum = (uint)packet.ReadBits(_bookBits); if (bookNum >= _books.Length) throw new InvalidDataException(); var book = _books[bookNum]; for (int i = 0; i < _order; i++) { var entry = book.DecodeScalar(packet); for (int d = 0; d < book.Dimensions; d++) { coefficients.Add(book[entry, d]); } //book.DecodeVQ(packet, t => coefficients.Add(t)); } data.Coeff = coefficients.ToArray(); } catch (EndOfStreamException) { // per the spec, an end of packet condition here indicates "no floor" data.Amp = 0.0f; } } return data; }
private void InitTree(DataPacket packet) { int num1 = 0; bool flag; if (packet.ReadBit()) { int num2 = (int)packet.ReadBits(5) + 1; int num3 = 0; while (num3 < this.Entries) { int num4 = (int)packet.ReadBits(Utils.ilog(this.Entries - num3)); while (--num4 >= 0) { this.Lengths[num3++] = num2; } ++num2; } num1 = 0; flag = false; } else { flag = packet.ReadBit(); for (int index = 0; index < this.Entries; ++index) { if (!flag || packet.ReadBit()) { this.Lengths[index] = (int)packet.ReadBits(5) + 1; ++num1; } else { this.Lengths[index] = -1; } } } this.MaxBits = Enumerable.Max((IEnumerable <int>) this.Lengths); int[] numArray1 = (int[])null; if (flag && num1 >= this.Entries >> 2) { numArray1 = new int[this.Entries]; Array.Copy((Array)this.Lengths, (Array)numArray1, this.Entries); flag = false; } int length = !flag ? 0 : num1; int[] numArray2 = (int[])null; int[] codeList = (int[])null; if (!flag) { codeList = new int[this.Entries]; } else if (length != 0) { numArray1 = new int[length]; codeList = new int[length]; numArray2 = new int[length]; } VorbisCodebook vorbisCodebook = this; int[] numArray3 = this.Lengths; int num5 = this.Entries; int[] numArray4 = numArray2; int num6 = flag ? 1 : 0; int sortedEntries = length; int[] codewords = codeList; int[] codewordLengths = numArray1; int[] len = numArray3; int n = num5; int[] values = numArray4; if (!vorbisCodebook.ComputeCodewords(num6 != 0, sortedEntries, codewords, codewordLengths, len, n, values)) { throw new InvalidDataException(); } this.LTree = Huffman.BuildLinkedList <int>(numArray2 ?? Enumerable.ToArray <int>(Enumerable.Range(0, codeList.Length)), numArray1 ?? this.Lengths, codeList); }
bool LoadBooks(DataPacket packet) { bool equal = true; byte[] sequence = new byte[] { 0x05, 0x76, 0x6f, 0x72, 0x62, 0x69, 0x73 }; byte[] packets = packet.ReadBytes(7); for (int i = 0; i < 7; i++) { if (packets[i] != sequence[i]) { equal = false; break; } } if (!equal) { return(false); } if (!_pagesSeen.Contains((_lastPageSeen = packet.PageSequenceNumber))) { _pagesSeen.Add(_lastPageSeen); } var bits = packet.BitsRead; _glueBits += packet.BitsRead; // get books Books = new VorbisCodebook[packet.ReadByte() + 1]; for (int i = 0; i < Books.Length; i++) { Books[i] = VorbisCodebook.Init(this, packet, i); } _bookBits += packet.BitsRead - bits; bits = packet.BitsRead; // get times Times = new VorbisTime[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Times.Length; i++) { Times[i] = VorbisTime.Init(this, packet); } _timeHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get floor Floors = new VorbisFloor[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Floors.Length; i++) { Floors[i] = VorbisFloor.Init(this, packet); } _floorHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get residue Residues = new VorbisResidue[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Residues.Length; i++) { Residues[i] = VorbisResidue.Init(this, packet); } _resHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get map Maps = new VorbisMapping[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Maps.Length; i++) { Maps[i] = VorbisMapping.Init(this, packet); } _mapHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get mode settings Modes = new VorbisMode[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Modes.Length; i++) { Modes[i] = VorbisMode.Init(this, packet); } _modeHdrBits += packet.BitsRead - bits; // check the framing bit if (!packet.ReadBit()) { throw new InvalidDataException(); } ++_glueBits; _wasteHdrBits += 8 * packet.Length - packet.BitsRead; _modeFieldBits = Utils.ilog(Modes.Length - 1); return(true); }
protected override void Init(DataPacket packet) { _order = (int)packet.ReadBits(8); _rate = (int)packet.ReadBits(16); _bark_map_size = (int)packet.ReadBits(16); _ampBits = (int)packet.ReadBits(6); _ampOfs = (int)packet.ReadBits(8); _books = new VorbisCodebook[(int)packet.ReadBits(4) + 1]; for (int i = 0; i < _books.Length; i++) { _books[i] = _vorbis.Books[(int)packet.ReadBits(8)]; } _bookBits = Utils.ilog(_books.Length); _barkMaps = new Dictionary<int, float[]>(); _barkMaps[_vorbis.Block0Size] = SynthesizeBarkCurve(_vorbis.Block0Size); _barkMaps[_vorbis.Block1Size] = SynthesizeBarkCurve(_vorbis.Block1Size); }
void InitLookupTable(DataPacket packet) { MapType = (int)packet.ReadBits(4); if (MapType == 0) { return; } var minValue = Utils.ConvertFromVorbisFloat32(packet.ReadUInt32()); var deltaValue = Utils.ConvertFromVorbisFloat32(packet.ReadUInt32()); var valueBits = (int)packet.ReadBits(4) + 1; var sequence_p = packet.ReadBit(); var lookupValueCount = Entries * Dimensions; var lookupTable = new float[lookupValueCount]; if (MapType == 1) { lookupValueCount = lookup1_values(); } var multiplicands = new uint[lookupValueCount]; for (var i = 0; i < lookupValueCount; i++) { multiplicands[i] = (uint)packet.ReadBits(valueBits); } // now that we have the initial data read in, calculate the entry tree if (MapType == 1) { for (var idx = 0; idx < Entries; idx++) { var last = 0.0; var idxDiv = 1; for (var i = 0; i < Dimensions; i++) { var moff = (idx / idxDiv) % lookupValueCount; var value = (float)multiplicands[moff] * deltaValue + minValue + last; lookupTable[idx * Dimensions + i] = (float)value; if (sequence_p) { last = value; } idxDiv *= lookupValueCount; } } } else { for (var idx = 0; idx < Entries; idx++) { var last = 0.0; var moff = idx * Dimensions; for (var i = 0; i < Dimensions; i++) { var value = multiplicands[moff] * deltaValue + minValue + last; lookupTable[idx * Dimensions + i] = (float)value; if (sequence_p) { last = value; } ++moff; } } } LookupTable = lookupTable; }
void LoadBooks(DataPacket packet) { packet.SkipBits(8); if ( !packet.ReadBytes ( 6 ).SequenceEqual ( new byte [] { 0x76, 0x6f, 0x72, 0x62, 0x69, 0x73 } ) ) throw new ArgumentException ( "Corrupted book header!" ); var bits = packet.BitsRead; _glueBits += packet.BitsRead; // get books Books = new VorbisCodebook[packet.ReadByte() + 1]; for (int i = 0; i < Books.Length; i++) { Books[i] = VorbisCodebook.Init(this, packet, i); } _bookBits += packet.BitsRead - bits; bits = packet.BitsRead; // get times Times = new VorbisTime[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Times.Length; i++) { Times[i] = VorbisTime.Init(this, packet); } _timeHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get floor Floors = new VorbisFloor[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Floors.Length; i++) { Floors[i] = VorbisFloor.Init(this, packet); } _floorHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get residue Residues = new VorbisResidue[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Residues.Length; i++) { Residues[i] = VorbisResidue.Init(this, packet); } _resHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get map Maps = new VorbisMapping[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Maps.Length; i++) { Maps[i] = VorbisMapping.Init(this, packet); } _mapHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get mode settings Modes = new VorbisMode[(int)packet.ReadBits(6) + 1]; for (int i = 0; i < Modes.Length; i++) { Modes[i] = VorbisMode.Init(this, packet); } _modeHdrBits += packet.BitsRead - bits; // check the framing bit if ( !packet.ReadBit () ) throw new ArgumentException (); ++_glueBits; _wasteHdrBits += 8 * packet.Length - packet.BitsRead; _modeFieldBits = Utils.ilog(Modes.Length - 1); }