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 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 num = (int)packet.ReadBits(8); if (vorbisMode.WindowType != 0 || vorbisMode.TransformType != 0 || num >= vorbis.Maps.Length) { throw new InvalidDataException(); } vorbisMode.Mapping = vorbis.Maps[num]; 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 int GetPacketLength(DataPacket curPacket, DataPacket lastPacket) { if (lastPacket == null || curPacket.IsResync) { return(0); } if (curPacket.ReadBit()) { return(0); } if (lastPacket.ReadBit()) { return(0); } int num = (int)curPacket.ReadBits(_modeFieldBits); if (num < 0 || num >= Modes.Length) { return(0); } VorbisMode vorbisMode = Modes[num]; num = (int)lastPacket.ReadBits(_modeFieldBits); if (num < 0 || num >= Modes.Length) { return(0); } VorbisMode vorbisMode2 = Modes[num]; return(vorbisMode.BlockSize / 4 + vorbisMode2.BlockSize / 4); }
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); }
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); }
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); }
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); }
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); }
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; }
bool LoadBooks(DataPacket packet) { if (!CheckForHeader(packet, bookHeader)) { 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.Create(this, packet, i); } _bookBits += packet.BitsRead - bits; bits = packet.BitsRead; // get times Times = new VorbisTime[(int)packet.ReadUBits(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.ReadUBits(6) + 1]; for (int i = 0; i < Floors.Length; i++) { Floors[i] = VorbisFloor.Create(this, packet); } _floorHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get residue Residues = new VorbisResidue[(int)packet.ReadUBits(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.ReadUBits(6) + 1]; for (int i = 0; i < Maps.Length; i++) { Maps[i] = VorbisMapping.Create(this, packet); } _mapHdrBits += packet.BitsRead - bits; bits = packet.BitsRead; // get mode settings Modes = new VorbisMode[(int)packet.ReadUBits(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); }
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); }
public bool UnpackPacket(DataPacket packet) { if (packet.ReadBit()) { return(false); } int num = _modeFieldBits; _mode = Modes[(uint)packet.ReadBits(_modeFieldBits)]; if (_mode.BlockFlag) { _prevFlag = packet.ReadBit(); _nextFlag = packet.ReadBit(); num += 2; } else { _prevFlag = (_nextFlag = false); } if (packet.IsShort) { return(false); } long bitsRead = packet.BitsRead; int num2 = _mode.BlockSize / 2; for (int i = 0; i < _channels; i++) { _floorData[i] = _mode.Mapping.ChannelSubmap[i].Floor.UnpackPacket(packet, _mode.BlockSize, i); _noExecuteChannel[i] = !_floorData[i].ExecuteChannel; Array.Clear(_residue[i], 0, num2); } VorbisMapping.CouplingStep[] couplingSteps = _mode.Mapping.CouplingSteps; foreach (VorbisMapping.CouplingStep couplingStep in couplingSteps) { if (_floorData[couplingStep.Angle].ExecuteChannel || _floorData[couplingStep.Magnitude].ExecuteChannel) { _floorData[couplingStep.Angle].ForceEnergy = true; _floorData[couplingStep.Magnitude].ForceEnergy = true; } } long num3 = packet.BitsRead - bitsRead; bitsRead = packet.BitsRead; VorbisMapping.Submap[] submaps = _mode.Mapping.Submaps; foreach (VorbisMapping.Submap submap in submaps) { for (int k = 0; k < _channels; k++) { if (_mode.Mapping.ChannelSubmap[k] != submap) { _floorData[k].ForceNoEnergy = true; } } float[][] array = submap.Residue.Decode(packet, _noExecuteChannel, _channels, _mode.BlockSize); for (int l = 0; l < _channels; l++) { float[] array2 = _residue[l]; float[] array3 = array[l]; for (int m = 0; m < num2; m++) { array2[m] += array3[m]; } } } _glueBits++; _modeBits += num; _floorBits += num3; _resBits += packet.BitsRead - bitsRead; _wasteBits += 8 * packet.Length - packet.BitsRead; _packetCount++; return(true); }
public bool LoadBooks(DataPacket packet) { if (!packet.ReadBytes(7).SequenceEqual(new byte[7] { 5, 118, 111, 114, 98, 105, 115 })) { return(false); } if (!_pagesSeen.Contains(_lastPageSeen = packet.PageSequenceNumber)) { _pagesSeen.Add(_lastPageSeen); } long bitsRead = packet.BitsRead; _glueBits += packet.BitsRead; Books = new VorbisCodebook[packet.ReadByte() + 1]; for (int i = 0; i < Books.Length; i++) { Books[i] = VorbisCodebook.Init(this, packet, i); } _bookBits += packet.BitsRead - bitsRead; bitsRead = packet.BitsRead; Times = new VorbisTime[(int)packet.ReadBits(6) + 1]; for (int j = 0; j < Times.Length; j++) { Times[j] = VorbisTime.Init(this, packet); } _timeHdrBits += packet.BitsRead - bitsRead; bitsRead = packet.BitsRead; Floors = new VorbisFloor[(int)packet.ReadBits(6) + 1]; for (int k = 0; k < Floors.Length; k++) { Floors[k] = VorbisFloor.Init(this, packet); } _floorHdrBits += packet.BitsRead - bitsRead; bitsRead = packet.BitsRead; Residues = new VorbisResidue[(int)packet.ReadBits(6) + 1]; for (int l = 0; l < Residues.Length; l++) { Residues[l] = VorbisResidue.Init(this, packet); } _resHdrBits += packet.BitsRead - bitsRead; bitsRead = packet.BitsRead; Maps = new VorbisMapping[(int)packet.ReadBits(6) + 1]; for (int m = 0; m < Maps.Length; m++) { Maps[m] = VorbisMapping.Init(this, packet); } _mapHdrBits += packet.BitsRead - bitsRead; bitsRead = packet.BitsRead; Modes = new VorbisMode[(int)packet.ReadBits(6) + 1]; for (int n = 0; n < Modes.Length; n++) { Modes[n] = VorbisMode.Init(this, packet); } _modeHdrBits += packet.BitsRead - bitsRead; if (!packet.ReadBit()) { throw new InvalidDataException(); } _glueBits++; _wasteHdrBits += 8 * packet.Length - packet.BitsRead; _modeFieldBits = Utils.ilog(Modes.Length - 1); return(true); }