| public ReadBits ( int count ) : ulong | ||
| count | int | The number of bits to read. |
| return | 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);
}
