claunia/cuetools.net
1
0
Fork 0
mirror of https://github.com/claunia/cuetools.net.git synced 2025-12-16 18:14:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

More code cleanup after decoding optimization

Browse Source
This commit is contained in:
Grigory Chudov
2013-03-19 22:31:43 -04:00
parent 264d9b7637
commit ecbb572b29
10 changed files with 310 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
CUETools.Codecs/BitReader.cs
View File

@@ -75,6 +75,7 @@ namespace CUETools.Codecs
private int buffer_len_m;
private int have_bits_m;
private ulong cache_m;
private ushort crc16_m;
public int Position
{
@@ -96,6 +97,7 @@ namespace CUETools.Codecs
buffer_len_m = 0;
have_bits_m = 0;
cache_m = 0;
crc16_m = 0;
}
public BitReader(byte* _buffer, int _pos, int _len)
@@ -110,6 +112,7 @@ namespace CUETools.Codecs
buffer_len_m = _len;
have_bits_m = 0;
cache_m = 0;
crc16_m = 0;
fill();
}
@@ -118,7 +121,9 @@ namespace CUETools.Codecs
while (have_bits_m < 56)
{
have_bits_m += 8;
cache_m |= (ulong)*(bptr_m++) << (64 - have_bits_m);
byte b = *(bptr_m++);
cache_m |= (ulong)b << (64 - have_bits_m);
crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ b]);
}
}
@@ -136,6 +141,36 @@ namespace CUETools.Codecs
have_bits_m -= bits;
}
public long read_long()
{
return ((long)readbits(32) << 32) | readbits(32);
}
public ulong read_ulong()
{
return ((ulong)readbits(32) << 32) | readbits(32);
}
public int read_int()
{
return (int)readbits(sizeof(int));
}
public uint read_uint()
{
return (uint)readbits(sizeof(uint));
}
public short read_short()
{
return (short)readbits(16);
}
public ushort read_ushort()
{
return (ushort)readbits(16);
}
/* supports reading 1 to 32 bits, in big endian format */
public uint readbits(int bits)
{
@@ -150,7 +185,7 @@ namespace CUETools.Codecs
{
if (bits <= 56)
return readbits(bits);
return (readbits(32) << bits - 32) | readbits(bits - 32);
return ((ulong)readbits(32) << bits - 32) | readbits(bits - 32);
}
/* reads a single bit */
@@ -168,7 +203,9 @@ namespace CUETools.Codecs
{
val += 8;
cache_m <<= 8;
cache_m |= (ulong)*(bptr_m++) << (64 - have_bits_m);
byte b = *(bptr_m++);
cache_m |= (ulong)b << (64 - have_bits_m);
crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ b]);
result = cache_m >> 56;
}
val += byte_to_unary_table[result];
@@ -183,9 +220,20 @@ namespace CUETools.Codecs
cache_m <<= have_bits_m & 7;
have_bits_m -= have_bits_m & 7;
}
}
}
public int readbits_signed(int bits)
public ushort get_crc16()
{
if (have_bits_m == 0)
return crc16_m;
ushort crc = 0;
int n = have_bits_m >> 3;
for (int i = 0; i < n; i++)
crc = (ushort)((crc << 8) ^ Crc16.table[(crc >> 8) ^ (byte)(cache_m >> (56 - (i << 3)))]);
return Crc16.Substract(crc16_m, crc, n);
}
public int readbits_signed(int bits)
{
int val = (int)readbits(bits);
val <<= (32 - bits);
@@ -252,11 +300,13 @@ namespace CUETools.Codecs
{
fill();
fixed (byte* unary_table = byte_to_unary_table)
fixed (ushort* t = Crc16.table)
{
uint mask = (1U << k) - 1;
byte* bptr = bptr_m;
int have_bits = have_bits_m;
ulong cache = cache_m;
ushort crc = crc16_m;
for (int i = n; i > 0; i--)
{
uint bits;
@@ -264,14 +314,18 @@ namespace CUETools.Codecs
while ((bits = unary_table[cache >> 56]) == 8)
{
cache <<= 8;
cache |= (ulong)*(bptr++) << (64 - have_bits);
byte b = *(bptr++);
cache |= (ulong)b << (64 - have_bits);
crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ b]);
}
uint msbs = bits + ((uint)(bptr - orig_bptr) << 3);
// assumes k <= 41 (have_bits < 41 + 7 + 1 + 8 == 57, so we don't loose bits here)
while (have_bits < 56)
{
have_bits += 8;
cache |= (ulong)*(bptr++) << (64 - have_bits);
byte b = *(bptr++);
cache |= (ulong)b << (64 - have_bits);
crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ b]);
}
int btsk = k + (int)bits + 1;
@@ -283,6 +337,7 @@ namespace CUETools.Codecs
have_bits_m = have_bits;
cache_m = cache;
bptr_m = bptr;
crc16_m = crc;
}
}
}

167
CUETools.Codecs/CRC/CRC16.cs
View File

@@ -1,42 +1,159 @@
using System;
namespace CUETools.Codecs
{
public class Crc16
public static class Crc16
{
ushort[] table = new ushort[256];
const int GF2_DIM = 16;
public static ushort[] table = new ushort[256];
private static readonly ushort[,] combineTable = new ushort[GF2_DIM, GF2_DIM];
private static readonly ushort[,] substractTable = new ushort[GF2_DIM, GF2_DIM];
public unsafe ushort ComputeChecksum(byte[] bytes, int pos, int count)
public static unsafe ushort ComputeChecksum(ushort crc, byte[] bytes, int pos, int count)
{
fixed (byte* bs = bytes)
return ComputeChecksum(bs + pos, count);
return ComputeChecksum(crc, bs + pos, count);
}
public unsafe ushort ComputeChecksum(byte* bytes, int count)
public static unsafe ushort ComputeChecksum(ushort crc, byte* bytes, int count)
{
ushort crc = 0;
fixed (ushort* t = table)
for (int i = count; i > 0; i--)
crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ *(bytes++)]);
return crc;
}
public Crc16()
const ushort polynomial = 0x8005;
const ushort reversePolynomial = 0xa001;
const ushort reversePolynomial2 = 0x4003;
static unsafe Crc16()
{
int bits = 16;
int poly16 = 0x8005;
int poly = (poly16 + (1 << bits));
for (ushort i = 0; i < table.Length; i++)
{
int crc = i;
for (int j = 0; j < bits; j++)
{
if ((crc & (1U << (bits - 1))) != 0)
crc = ((crc << 1) ^ poly);
else
crc <<= 1;
}
//table[i] = (crc & ((1<<bits)-1));
table[i] = (ushort)(crc & 0xffff);
}
}
}
int poly = (polynomial + (1 << GF2_DIM));
for (ushort i = 0; i < table.Length; i++)
{
int crc = i;
for (int j = 0; j < GF2_DIM; j++)
{
if ((crc & (1U << (GF2_DIM - 1))) != 0)
crc = ((crc << 1) ^ poly);
else
crc <<= 1;
}
table[i] = (ushort)(crc & ((1 << GF2_DIM) - 1));
}
combineTable[0, 0] = reversePolynomial;
substractTable[0, GF2_DIM - 1] = reversePolynomial2;
for (int n = 1; n < GF2_DIM; n++)
{
combineTable[0, n] = (ushort)(1 << (n - 1));
substractTable[0, n - 1] = (ushort)(1 << n);
}
fixed (ushort* ct = &combineTable[0, 0], st = &substractTable[0, 0])
{
//for (int i = 0; i < GF2_DIM; i++)
// st[32 + i] = ct[i];
//invert_binary_matrix(st + 32, st, GF2_DIM);
for (int i = 1; i < GF2_DIM; i++)
{
gf2_matrix_square(ct + i * GF2_DIM, ct + (i - 1) * GF2_DIM);
gf2_matrix_square(st + i * GF2_DIM, st + (i - 1) * GF2_DIM);
}
}
}
private static unsafe ushort gf2_matrix_times(ushort* mat, ushort uvec)
{
int vec = ((int) uvec) << 16;
return (ushort)(
(*(mat++) & ((vec << 15) >> 31)) ^
(*(mat++) & ((vec << 14) >> 31)) ^
(*(mat++) & ((vec << 13) >> 31)) ^
(*(mat++) & ((vec << 12) >> 31)) ^
(*(mat++) & ((vec << 11) >> 31)) ^
(*(mat++) & ((vec << 10) >> 31)) ^
(*(mat++) & ((vec << 09) >> 31)) ^
(*(mat++) & ((vec << 08) >> 31)) ^
(*(mat++) & ((vec << 07) >> 31)) ^
(*(mat++) & ((vec << 06) >> 31)) ^
(*(mat++) & ((vec << 05) >> 31)) ^
(*(mat++) & ((vec << 04) >> 31)) ^
(*(mat++) & ((vec << 03) >> 31)) ^
(*(mat++) & ((vec << 02) >> 31)) ^
(*(mat++) & ((vec << 01) >> 31)) ^
(*(mat++) & (vec >> 31)));
}
private static unsafe void gf2_matrix_square(ushort* square, ushort* mat)
{
for (int n = 0; n < GF2_DIM; n++)
square[n] = gf2_matrix_times(mat, mat[n]);
}
public static unsafe ushort Combine(ushort crc1, ushort crc2, long len2)
{
crc1 = (ushort)Crc32.Reflect(crc1, 16);
crc2 = (ushort)Crc32.Reflect(crc2, 16);
/* degenerate case */
if (len2 == 0)
return crc1;
if (crc1 == 0)
return crc2;
if (len2 < 0)
throw new ArgumentException("crc.Combine length cannot be negative", "len2");
fixed (ushort* ct = &combineTable[0, 0])
{
int n = 3;
do
{
/* apply zeros operator for this bit of len2 */
if ((len2 & 1) != 0)
crc1 = gf2_matrix_times(ct + GF2_DIM * n, crc1);
len2 >>= 1;
n = (n + 1) & (GF2_DIM - 1);
/* if no more bits set, then done */
} while (len2 != 0);
}
/* return combined crc */
crc1 ^= crc2;
crc1 = (ushort)Crc32.Reflect(crc1, 16);
return crc1;
}
public static unsafe ushort Substract(ushort crc1, ushort crc2, long len2)
{
crc1 = (ushort)Crc32.Reflect(crc1, 16);
crc2 = (ushort)Crc32.Reflect(crc2, 16);
/* degenerate case */
if (len2 == 0)
return crc1;
if (len2 < 0)
throw new ArgumentException("crc.Combine length cannot be negative", "len2");
crc1 ^= crc2;
fixed (ushort* st = &substractTable[0, 0])
{
int n = 3;
do
{
/* apply zeros operator for this bit of len2 */
if ((len2 & 1) != 0)
crc1 = gf2_matrix_times(st + GF2_DIM * n, crc1);
len2 >>= 1;
n = (n + 1) & (GF2_DIM - 1);
/* if no more bits set, then done */
} while (len2 != 0);
}
/* return combined crc */
crc1 = (ushort)Crc32.Reflect(crc1, 16);
return crc1;
}
}
}

85
CUETools.Codecs/CRC/CRC32.cs
View File

@@ -42,7 +42,7 @@ namespace CUETools.Codecs
return crc;
}
static uint Reflect(uint val, int ch)
internal static uint Reflect(uint val, int ch)
{
uint value = 0;
// Swap bit 0 for bit 7
@@ -56,7 +56,9 @@ namespace CUETools.Codecs
return value;
}
const uint ulPolynomial = 0x04c11db7;
const uint uPolynomial = 0x04c11db7;
const uint uReversePolynomial = 0xedb88320;
const uint uReversePolynomial2 = 0xdb710641;
private static readonly uint[,] combineTable;
private static readonly uint[,] substractTable;
@@ -122,13 +124,13 @@ namespace CUETools.Codecs
{
table[i] = Reflect(i, 8) << 24;
for (int j = 0; j < 8; j++)
table[i] = (table[i] << 1) ^ ((table[i] & (1U << 31)) == 0 ? 0 : ulPolynomial);
table[i] = (table[i] << 1) ^ ((table[i] & (1U << 31)) == 0 ? 0 : uPolynomial);
table[i] = Reflect(table[i], 32);
}
combineTable = new uint[GF2_DIM, GF2_DIM];
substractTable = new uint[GF2_DIM, GF2_DIM];
combineTable[0, 0] = 0xedb88320; /* CRC-32 polynomial */
substractTable[0, 31] = 0xdb710641;
combineTable[0, 0] = uReversePolynomial;
substractTable[0, 31] = uReversePolynomial2;
for (int n = 1; n < GF2_DIM; n++)
{
combineTable[0, n] = 1U << (n - 1);
@@ -151,41 +153,44 @@ namespace CUETools.Codecs
const int GF2_DIM = 32;
//const int GF2_DIM2 = 67;
private static unsafe uint gf2_matrix_times(uint* mat, uint vec)
{
return *(mat++) * (vec & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1) ^
*(mat++) * ((vec >>= 1) & 1);
}
private static unsafe uint gf2_matrix_times(uint* umat, uint uvec)
{
int vec = (int)uvec;
int* mat = (int*)umat;
return (uint)(
(*(mat++) & ((vec << 31) >> 31)) ^
(*(mat++) & ((vec << 30) >> 31)) ^
(*(mat++) & ((vec << 29) >> 31)) ^
(*(mat++) & ((vec << 28) >> 31)) ^
(*(mat++) & ((vec << 27) >> 31)) ^
(*(mat++) & ((vec << 26) >> 31)) ^
(*(mat++) & ((vec << 25) >> 31)) ^
(*(mat++) & ((vec << 24) >> 31)) ^
(*(mat++) & ((vec << 23) >> 31)) ^
(*(mat++) & ((vec << 22) >> 31)) ^
(*(mat++) & ((vec << 21) >> 31)) ^
(*(mat++) & ((vec << 20) >> 31)) ^
(*(mat++) & ((vec << 19) >> 31)) ^
(*(mat++) & ((vec << 18) >> 31)) ^
(*(mat++) & ((vec << 17) >> 31)) ^
(*(mat++) & ((vec << 16) >> 31)) ^
(*(mat++) & ((vec << 15) >> 31)) ^
(*(mat++) & ((vec << 14) >> 31)) ^
(*(mat++) & ((vec << 13) >> 31)) ^
(*(mat++) & ((vec << 12) >> 31)) ^
(*(mat++) & ((vec << 11) >> 31)) ^
(*(mat++) & ((vec << 10) >> 31)) ^
(*(mat++) & ((vec << 09) >> 31)) ^
(*(mat++) & ((vec << 08) >> 31)) ^
(*(mat++) & ((vec << 07) >> 31)) ^
(*(mat++) & ((vec << 06) >> 31)) ^
(*(mat++) & ((vec << 05) >> 31)) ^
(*(mat++) & ((vec << 04) >> 31)) ^
(*(mat++) & ((vec << 03) >> 31)) ^
(*(mat++) & ((vec << 02) >> 31)) ^
(*(mat++) & ((vec << 01) >> 31)) ^
(*(mat++) & (vec >> 31)));
}
/* ========================================================================= */
private static unsafe void gf2_matrix_square(uint *square, uint *mat)