|
private DecodeScalar ( |
||
| packet | ||
| return | int | |
internal override VorbisFloor.PacketData UnpackPacket(DataPacket packet, int blockSize)
{
VorbisFloor.Floor0.PacketData0 packetData0_1 = new VorbisFloor.Floor0.PacketData0();
packetData0_1.BlockSize = blockSize;
VorbisFloor.Floor0.PacketData0 packetData0_2 = packetData0_1;
packetData0_2.Amp = (float)packet.ReadBits(this._ampBits);
if ((double)packetData0_2.Amp > 0.0)
{
try
{
List <float> list = new List <float>();
uint num = (uint)packet.ReadBits(this._bookBits);
if ((long)num >= (long)this._books.Length)
{
throw new InvalidDataException();
}
VorbisCodebook vorbisCodebook = this._books[(IntPtr)num];
for (int index1 = 0; index1 < this._order; ++index1)
{
int index2 = vorbisCodebook.DecodeScalar(packet);
for (int index3 = 0; index3 < vorbisCodebook.Dimensions; ++index3)
{
list.Add(vorbisCodebook[index2, index3]);
}
}
packetData0_2.Coeff = list.ToArray();
}
catch (EndOfStreamException ex)
{
packetData0_2.Amp = 0.0f;
}
}
return((VorbisFloor.PacketData)packetData0_2);
}
public override bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
int num = 0;
offset /= _channels;
int num2 = 0;
while (num2 < partitionSize)
{
int num3 = codebook.DecodeScalar(packet);
if (num3 == -1)
{
return(true);
}
int num4 = 0;
while (num4 < codebook.Dimensions)
{
residue[num][offset] += codebook[num3, num4];
if (++num == _channels)
{
num = 0;
offset++;
}
num4++;
num2++;
}
}
return(false);
}
protected override bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
var chPtr = 0;
offset /= _channels;
for (int c = 0; c < partitionSize;)
{
var entry = codebook.DecodeScalar(packet);
if (entry == -1)
{
return(true);
}
for (var d = 0; d < codebook.Dimensions; d++, c++)
{
residue[chPtr][offset] += codebook[entry, d];
if (++chPtr == _channels)
{
chPtr = 0;
offset++;
}
}
}
return(false);
}
internal override float[][] Decode(DataPacket packet, bool[] doNotDecode, int channels, int blockSize)
{
float[][] numArray = ACache.Get <float>(channels, blockSize);
int num1 = this._partitionSize / channels;
if (Enumerable.Contains <bool>((IEnumerable <bool>)doNotDecode, false) && this._nToRead > 0)
{
int[][] buffer = ACache.Get <int>(this._partWords, this._classWordsPerCodeWord);
for (int index1 = 0; index1 < this._maxPasses; ++index1)
{
int num2 = 0;
int index2 = 0;
int num3 = this._begin;
while (num2 < this._partsToRead)
{
if (index1 == 0)
{
int num4 = this._classBook.DecodeScalar(packet);
for (int index3 = this._classWordsPerCodeWord - 1; index3 >= 0 && num4 > 0; --index3)
{
buffer[index2][index3] = num4 % this._classifications;
num4 /= this._classifications;
}
}
for (int index3 = 0; index3 < this._classWordsPerCodeWord && num2 < this._partsToRead; ++index3)
{
VorbisCodebook vorbisCodebook = this._books[buffer[index2][index3]][index1];
if (vorbisCodebook != null && vorbisCodebook.MapType != 0)
{
int index4 = 0;
int num4 = vorbisCodebook.Dimensions;
int num5 = 0;
int index5 = num3 / channels;
while (num5 < num1)
{
int index6 = vorbisCodebook.DecodeScalar(packet);
for (int index7 = 0; index7 < num4; ++index7)
{
numArray[index4][index5] += vorbisCodebook[index6, index7];
if (++index4 == channels)
{
index4 = 0;
++num5;
++index5;
}
}
}
}
++num2;
num3 += this._partitionSize;
}
++index2;
}
}
ACache.Return <int>(ref buffer);
}
return(numArray);
}
internal override PacketData UnpackPacket(DataPacket packet, int blockSize, int channel)
{
var data = _reusablePacketData[channel];
data.BlockSize = blockSize;
data.ForceEnergy = false;
data.ForceNoEnergy = false;
data.Amp = packet.ReadUBits(_ampBits);
if (data.Amp > 0f)
{
// this is pretty well stolen directly from libvorbis... BSD license
Array.Clear(data.Coeff, 0, data.Coeff.Length);
data.Amp = data.Amp / _ampDiv * _ampOfs;
uint bookNum = (uint)packet.ReadUBits(_bookBits);
if (bookNum >= _books.Length)
{
// we ran out of data or the packet is corrupt... 0 the floor and return
data.Amp = 0;
return(data);
}
VorbisCodebook book = _books[bookNum];
// first, the book decode...
for (int i = 0; i < _order;)
{
int entry = book.DecodeScalar(packet);
if (entry == -1)
{
// we ran out of data or the packet is corrupt... 0 the floor and return
data.Amp = 0;
return(data);
}
for (int j = 0; i < _order && j < book.Dimensions; j++, i++)
{
data.Coeff[i] = book[entry, j];
}
}
// then, the "averaging"
float last = 0f;
for (int j = 0; j < _order;)
{
for (int k = 0; j < _order && k < book.Dimensions; j++, k++)
{
data.Coeff[j] += last;
}
last = data.Coeff[j - 1];
}
}
return(data);
}
internal override PacketData UnpackPacket(DataPacket packet, int blockSize, int channel)
{
PacketData0 packetData = _reusablePacketData[channel];
packetData.BlockSize = blockSize;
packetData.ForceEnergy = false;
packetData.ForceNoEnergy = false;
packetData.Amp = (float)(double)packet.ReadBits(_ampBits);
if (packetData.Amp > 0f)
{
Array.Clear(packetData.Coeff, 0, packetData.Coeff.Length);
packetData.Amp = packetData.Amp / (float)_ampDiv * (float)_ampOfs;
uint num = (uint)packet.ReadBits(_bookBits);
if (num >= _books.Length)
{
packetData.Amp = 0f;
return(packetData);
}
VorbisCodebook vorbisCodebook = _books[num];
int i = 0;
while (i < _order)
{
int num2 = vorbisCodebook.DecodeScalar(packet);
if (num2 == -1)
{
packetData.Amp = 0f;
return(packetData);
}
int num3 = 0;
for (; i < _order; i++)
{
if (num3 >= vorbisCodebook.Dimensions)
{
break;
}
packetData.Coeff[i] = vorbisCodebook[num2, num3];
num3++;
}
}
float num4 = 0f;
int num5 = 0;
while (num5 < _order)
{
int num6 = 0;
while (num5 < _order && num6 < vorbisCodebook.Dimensions)
{
packetData.Coeff[num5] += num4;
num5++;
num6++;
}
num4 = packetData.Coeff[num5 - 1];
}
}
return(packetData);
}
protected override void WriteVectors(VorbisCodebook codebook, DataPacket packet, float[] residue, int offset, int channel)
{
int num = 0;
while (num < this._partitionSize)
{
int index1 = codebook.DecodeScalar(packet);
for (int index2 = 0; index2 < codebook.Dimensions; ++index2)
{
residue[offset + num++] += codebook[index1, index2];
}
}
}
protected virtual void WriteVectors(VorbisCodebook codebook, DataPacket packet, float[] residue, int offset, int channel)
{
int num1 = this._nToRead / codebook.Dimensions;
for (int index1 = 0; index1 < num1; ++index1)
{
int num2 = 0;
int index2 = codebook.DecodeScalar(packet);
for (int index3 = 0; index3 < codebook.Dimensions; ++index3)
{
residue[offset + index1 + num2++ *num1] += codebook[index2, index3];
}
}
}
internal override VorbisFloor.PacketData UnpackPacket(DataPacket packet, int blockSize)
{
VorbisFloor.Floor1.PacketData1 packetData1_1 = new VorbisFloor.Floor1.PacketData1();
packetData1_1.BlockSize = blockSize;
VorbisFloor.Floor1.PacketData1 packetData1_2 = packetData1_1;
if (packet.ReadBit())
{
try
{
int index1 = 2;
int[] numArray = ACache.Get <int>(64);
numArray[0] = (int)packet.ReadBits(this._yBits);
numArray[1] = (int)packet.ReadBits(this._yBits);
for (int index2 = 0; index2 < this._partitionClass.Length; ++index2)
{
int index3 = this._partitionClass[index2];
int num1 = this._classDimensions[index3];
int num2 = this._classSubclasses[index3];
int num3 = (1 << num2) - 1;
uint num4 = 0U;
if (num2 > 0)
{
num4 = (uint)this._classMasterbooks[index3].DecodeScalar(packet);
}
for (int index4 = 0; index4 < num1; ++index4)
{
VorbisCodebook vorbisCodebook = this._subclassBooks[index3][(long)num4 & (long)num3];
num4 >>= num2;
if (vorbisCodebook != null)
{
numArray[index1] = vorbisCodebook.DecodeScalar(packet);
}
++index1;
}
}
packetData1_2.Posts = numArray;
packetData1_2.PostCount = index1;
}
catch (EndOfStreamException ex)
{
}
}
return((VorbisFloor.PacketData)packetData1_2);
}
protected override bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
var res = residue[channel];
for (int i = 0; i < partitionSize;)
{
var entry = codebook.DecodeScalar(packet);
if (entry == -1)
{
return(true);
}
for (int j = 0; j < codebook.Dimensions; i++, j++)
{
res[offset + i] += codebook[entry, j];
}
}
return(false);
}
internal override PacketData UnpackPacket(DataPacket packet, int blockSize, int channel)
{
PacketData1 packetData = _reusablePacketData[channel];
packetData.BlockSize = blockSize;
packetData.ForceEnergy = false;
packetData.ForceNoEnergy = false;
packetData.PostCount = 0;
Array.Clear(packetData.Posts, 0, 64);
if (packet.ReadBit())
{
int num = 2;
packetData.Posts[0] = (int)packet.ReadBits(_yBits);
packetData.Posts[1] = (int)packet.ReadBits(_yBits);
for (int i = 0; i < _partitionClass.Length; i++)
{
int num2 = _partitionClass[i];
int num3 = _classDimensions[num2];
int num4 = _classSubclasses[num2];
int num5 = (1 << num4) - 1;
uint num6 = 0u;
if (num4 > 0 && (num6 = (uint)_classMasterbooks[num2].DecodeScalar(packet)) == uint.MaxValue)
{
num = 0;
break;
}
for (int j = 0; j < num3; j++)
{
VorbisCodebook vorbisCodebook = _subclassBooks[num2][num6 & num5];
num6 >>= num4;
if (vorbisCodebook != null && (packetData.Posts[num] = vorbisCodebook.DecodeScalar(packet)) == -1)
{
num = 0;
i = _partitionClass.Length;
break;
}
num++;
}
}
packetData.PostCount = num;
}
return(packetData);
}
public override bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
float[] array = residue[channel];
int num = 0;
while (num < partitionSize)
{
int num2 = codebook.DecodeScalar(packet);
if (num2 == -1)
{
return(true);
}
for (int i = 0; i < codebook.Dimensions; i++)
{
array[offset + num] += codebook[num2, i];
num++;
}
}
return(false);
}
virtual protected bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
var res = residue[channel];
var step = partitionSize / codebook.Dimensions;
for (int i = 0; i < step; i++)
{
if ((_entryCache[i] = codebook.DecodeScalar(packet)) == -1)
{
return(true);
}
}
for (int i = 0; i < codebook.Dimensions; i++)
{
for (int j = 0; j < step; j++, offset++)
{
res[offset] += codebook[_entryCache[j], i];
}
}
return(false);
}
public virtual bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
float[] array = residue[channel];
int num = partitionSize / codebook.Dimensions;
for (int i = 0; i < num; i++)
{
if ((_entryCache[i] = codebook.DecodeScalar(packet)) == -1)
{
return(true);
}
}
for (int j = 0; j < codebook.Dimensions; j++)
{
int num2 = 0;
while (num2 < num)
{
array[offset] += codebook[_entryCache[num2], j];
num2++;
offset++;
}
}
return(false);
}
internal override float[][] Decode(DataPacket packet, bool[] doNotDecode, int channels, int blockSize)
{
var residue = GetResidueBuffer(doNotDecode.Length);
// this is pretty well stolen directly from libvorbis... BSD license
var end = _end < blockSize / 2 ? _end : blockSize / 2;
var n = end - _begin;
if (n > 0 && doNotDecode.Contains(false))
{
var partVals = n / _partitionSize;
var partWords = (partVals + _classBook.Dimensions - 1) / _classBook.Dimensions;
for (int j = 0; j < channels; j++)
{
Array.Clear(_partWordCache[j], 0, partWords);
}
for (int s = 0; s < _maxStages; s++)
{
for (int i = 0, l = 0; i < partVals; l++)
{
if (s == 0)
{
for (int j = 0; j < channels; j++)
{
try
{
_partWordCache[j][l] = _decodeMap[_classBook.DecodeScalar(packet)];
}
catch (IndexOutOfRangeException)
{
i = partVals;
s = _maxStages;
break;
}
}
}
for (int k = 0; i < partVals && k < _classBook.Dimensions; k++, i++)
{
var offset = _begin + i * _partitionSize;
for (int j = 0; j < channels; j++)
{
var idx = _partWordCache[j][l][k];
if ((_cascade[idx] & (1 << s)) != 0)
{
var book = _books[idx][s];
if (book != null)
{
if (WriteVectors(book, packet, residue, j, offset, _partitionSize))
{
// bad packet... exit now and try to use what we already have
i = partVals;
s = _maxStages;
break;
}
}
}
}
}
}
}
}
return(residue);
}
protected override void WriteVectors(VorbisCodebook codebook, DataPacket packet, float[] residue, int offset, int channel)
{
for (int i = 0; i < _partitionSize;)
{
var entry = codebook.DecodeScalar(packet);
for (var d = 0; d < codebook.Dimensions; d++)
{
residue[offset + i++] += codebook[entry, d];
}
}
}
protected virtual void WriteVectors(VorbisCodebook codebook, DataPacket packet, float[] residue, int offset, int channel)
{
var step = _nToRead / codebook.Dimensions;
for (int i = 0; i < step; i++)
{
var j = 0;
var entry = codebook.DecodeScalar(packet);
for (var d = 0; d < codebook.Dimensions; d++)
{
residue[offset + i + j++ * step] += codebook[entry, d];
}
}
}
protected override bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
var chPtr = 0;
offset /= _channels;
for (int c = 0; c < partitionSize; )
{
var entry = codebook.DecodeScalar(packet);
if (entry == -1)
{
return true;
}
for (var d = 0; d < codebook.Dimensions; d++, c++)
{
residue[chPtr][offset] += codebook[entry, d];
if (++chPtr == _channels)
{
chPtr = 0;
offset++;
}
}
}
return false;
}
protected override bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
var res = residue[channel];
for (int i = 0; i < partitionSize; )
{
var entry = codebook.DecodeScalar(packet);
if (entry == -1)
{
return true;
}
for (int j = 0; j < codebook.Dimensions; i++, j++)
{
res[offset + i] += codebook[entry, j];
}
}
return false;
}
protected virtual void WriteVectors(VorbisCodebook codebook, DataPacket packet, float[] residue, int offset, int channel)
{
int num1 = this._nToRead / codebook.Dimensions;
for (int index1 = 0; index1 < num1; ++index1)
{
int num2 = 0;
int index2 = codebook.DecodeScalar(packet);
for (int index3 = 0; index3 < codebook.Dimensions; ++index3)
residue[offset + index1 + num2++ * num1] += codebook[index2, index3];
}
}
internal override float[][] Decode(DataPacket packet, bool[] doNotDecode, int channels, int blockSize)
{
float[][] residueBuffer = GetResidueBuffer(doNotDecode.Length);
int num = ((_end < blockSize / 2) ? _end : (blockSize / 2)) - _begin;
if (num > 0 && doNotDecode.Contains(value: false))
{
int num2 = num / _partitionSize;
int length = (num2 + _classBook.Dimensions - 1) / _classBook.Dimensions;
for (int i = 0; i < channels; i++)
{
Array.Clear(_partWordCache[i], 0, length);
}
for (int j = 0; j < _maxStages; j++)
{
int k = 0;
int num3 = 0;
while (k < num2)
{
if (j == 0)
{
for (int l = 0; l < channels; l++)
{
int num4 = _classBook.DecodeScalar(packet);
if (num4 >= 0 && num4 < _decodeMap.Length)
{
_partWordCache[l][num3] = _decodeMap[num4];
continue;
}
k = num2;
j = _maxStages;
break;
}
}
int num5 = 0;
for (; k < num2; k++)
{
if (num5 >= _classBook.Dimensions)
{
break;
}
int offset = _begin + k * _partitionSize;
for (int m = 0; m < channels; m++)
{
int num6 = _partWordCache[m][num3][num5];
if ((_cascade[num6] & (1 << j)) != 0)
{
VorbisCodebook vorbisCodebook = _books[num6][j];
if (vorbisCodebook != null && WriteVectors(vorbisCodebook, packet, residueBuffer, m, offset, _partitionSize))
{
k = num2;
j = _maxStages;
break;
}
}
}
num5++;
}
num3++;
}
}
}
return(residueBuffer);
}
protected override void WriteVectors(VorbisCodebook codebook, DataPacket packet, float[] residue, int offset, int channel)
{
int num = 0;
while (num < this._partitionSize)
{
int index1 = codebook.DecodeScalar(packet);
for (int index2 = 0; index2 < codebook.Dimensions; ++index2)
residue[offset + num++] += codebook[index1, index2];
}
}
virtual protected bool WriteVectors(VorbisCodebook codebook, DataPacket packet, float[][] residue, int channel, int offset, int partitionSize)
{
var res = residue[channel];
var step = partitionSize / codebook.Dimensions;
for (int i = 0; i < step; i++)
{
if ((_entryCache[i] = codebook.DecodeScalar(packet)) == -1)
{
return true;
}
}
for (int i = 0; i < codebook.Dimensions; i++)
{
for (int j = 0; j < step; j++, offset++)
{
res[offset] += codebook[_entryCache[j], i];
}
}
return false;
}