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

Fruitless optimizations

Browse Source
This commit is contained in:
Grigory Chudov
2013-03-24 19:18:34 -04:00
parent 78fc1f0287
commit 79b0cb069b
3 changed files with 267 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

163
CUETools.Codecs.FLAKE/FlakeReader.cs
View File

@@ -350,14 +350,14 @@ namespace CUETools.Codecs.FLAKE
unsafe void decode_subframe_constant(BitReader bitreader, FlacFrame frame, int ch) unsafe void decode_subframe_constant(BitReader bitreader, FlacFrame frame, int ch)
{ {
int obits = frame.subframes[ch].obits; int obits = frame.subframes[ch].obits;
frame.subframes[ch].best.residual[0] = bitreader.readbits_signed(obits); frame.subframes[ch].samples[0] = bitreader.readbits_signed(obits);
} }
unsafe void decode_subframe_verbatim(BitReader bitreader, FlacFrame frame, int ch) unsafe void decode_subframe_verbatim(BitReader bitreader, FlacFrame frame, int ch)
{ {
int obits = frame.subframes[ch].obits; int obits = frame.subframes[ch].obits;
for (int i = 0; i < frame.blocksize; i++) for (int i = 0; i < frame.blocksize; i++)
frame.subframes[ch].best.residual[i] = bitreader.readbits_signed(obits); frame.subframes[ch].samples[i] = bitreader.readbits_signed(obits);
} }
unsafe void decode_residual(BitReader bitreader, FlacFrame frame, int ch) unsafe void decode_residual(BitReader bitreader, FlacFrame frame, int ch)
@@ -376,27 +376,122 @@ namespace CUETools.Codecs.FLAKE
int rice_len = 4 + frame.subframes[ch].best.rc.coding_method; int rice_len = 4 + frame.subframes[ch].best.rc.coding_method;
// residual // residual
int j = frame.subframes[ch].best.order; int order = frame.subframes[ch].best.order;
int* r = frame.subframes[ch].best.residual + j; int shift = frame.subframes[ch].best.shift;
for (int p = 0; p < (1 << frame.subframes[ch].best.rc.porder); p++) //int* r = frame.subframes[ch].best.residual;
{ int* s = frame.subframes[ch].samples + order;
if (p == 1) res_cnt = psize; //for (int i = 0; i < order; i++)
int n = Math.Min(res_cnt, frame.blocksize - j); // *(s++) = *(r++);
fixed (byte* unary_table = BitReader.byte_to_unary_table)
fixed (ushort* t = Crc16.table)
fixed (int* coefs = frame.subframes[ch].best.coefs)
{
//int* cc = stackalloc int[34];
//for (int i = 0; i < 34; i++)
// cc[i] = 0;
int k = frame.subframes[ch].best.rc.rparams[p] = (int)bitreader.readbits(rice_len); //switch (frame.subframes[ch].best.type)
if (k == (1 << rice_len) - 1) //{
{ // case SubframeType.Fixed:
k = frame.subframes[ch].best.rc.esc_bps[p] = (int)bitreader.readbits(5); // shift = 0;
for (int i = n; i > 0; i--) // switch (order)
*(r++) = bitreader.readbits_signed((int)k); // {
} // case 0:
else // break;
{ // case 1:
bitreader.read_rice_block(n, (int)k, r); // cc[0] = 1;
r += n; // break;
} // case 2:
j += n; // cc[0] = -1;
} // cc[1] = 2;
// break;
// case 3:
// cc[0] = 1;
// cc[1] = -3;
// cc[2] = 3;
// break;
// case 4:
// cc[0] = -1;
// cc[1] = 4;
// cc[2] = -2;
// cc[3] = 4;
// break;
// }
// break;
// case SubframeType.LPC:
// for (int i = 0; i < order; i++)
// cc[i] = coefs[order - 1 - i];
// break;
//}
for (int p = 0; p < (1 << frame.subframes[ch].best.rc.porder); p++)
{
if (p == 1) res_cnt = psize;
int n = Math.Min(res_cnt, frame.blocksize - (int)(s - frame.subframes[ch].samples));
int k = frame.subframes[ch].best.rc.rparams[p] = (int)bitreader.readbits(rice_len);
if (k == (1 << rice_len) - 1)
{
k = frame.subframes[ch].best.rc.esc_bps[p] = (int)bitreader.readbits(5);
bitreader.read_int_block(n, k, s);
s += n;
}
else
{
bitreader.read_rice_block(n, k, s);
s += n;
//bitreader.fill();
//uint mask = (1U << k) - 1;
//byte* bptr = bitreader.bptr_m;
//int have_bits = bitreader.have_bits_m;
//ulong cache = bitreader.cache_m;
//ushort crc = bitreader.crc16_m;
//for (int i = n; i > 0; i--)
//{
// uint bits;
// byte* orig_bptr = bptr;
// while ((bits = unary_table[cache >> 56]) == 8)
// {
// cache <<= 8;
// 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;
// byte b = *(bptr++);
// cache |= (ulong)b << (64 - have_bits);
// crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ b]);
// }
// int btsk = k + (int)bits + 1;
// uint uval = (msbs << k) | (uint)((cache >> (64 - btsk)) & mask);
// cache <<= btsk;
// have_bits -= btsk;
// int res = (int)(uval >> 1 ^ -(int)(uval & 1));
// //int* so = s - order;
// //int pred =
// // cc[00] * so[00] + cc[01] * so[01]
// // + cc[02] * so[02] + cc[03] * so[03]
// // + cc[04] * so[04] + cc[05] * so[05]
// // + cc[06] * so[06] + cc[07] * so[07]
// // + cc[08] * so[08] + cc[09] * so[09]
// // + cc[10] * so[10] + cc[11] * so[11];
// //*(s++) = res + (pred >> shift);
// // restore_samples will overwrite s if needed
// *(s++) = res;
//}
//bitreader.have_bits_m = have_bits;
//bitreader.cache_m = cache;
//bitreader.bptr_m = bptr;
//bitreader.crc16_m = crc;
}
}
}
} }
unsafe void decode_subframe_fixed(BitReader bitreader, FlacFrame frame, int ch) unsafe void decode_subframe_fixed(BitReader bitreader, FlacFrame frame, int ch)
@@ -404,7 +499,7 @@ namespace CUETools.Codecs.FLAKE
// warm-up samples // warm-up samples
int obits = frame.subframes[ch].obits; int obits = frame.subframes[ch].obits;
for (int i = 0; i < frame.subframes[ch].best.order; i++) for (int i = 0; i < frame.subframes[ch].best.order; i++)
frame.subframes[ch].best.residual[i] = bitreader.readbits_signed(obits); frame.subframes[ch].samples[i] = bitreader.readbits_signed(obits);
// residual // residual
decode_residual(bitreader, frame, ch); decode_residual(bitreader, frame, ch);
@@ -415,7 +510,7 @@ namespace CUETools.Codecs.FLAKE
// warm-up samples // warm-up samples
int obits = frame.subframes[ch].obits; int obits = frame.subframes[ch].obits;
for (int i = 0; i < frame.subframes[ch].best.order; i++) for (int i = 0; i < frame.subframes[ch].best.order; i++)
frame.subframes[ch].best.residual[i] = bitreader.readbits_signed(obits); frame.subframes[ch].samples[i] = bitreader.readbits_signed(obits);
// LPC coefficients // LPC coefficients
frame.subframes[ch].best.cbits = (int)bitreader.readbits(4) + 1; // lpc_precision frame.subframes[ch].best.cbits = (int)bitreader.readbits(4) + 1; // lpc_precision
@@ -493,15 +588,15 @@ namespace CUETools.Codecs.FLAKE
{ {
FlacSubframeInfo sub = frame.subframes[ch]; FlacSubframeInfo sub = frame.subframes[ch];
AudioSamples.MemCpy(sub.samples, sub.best.residual, sub.best.order); //AudioSamples.MemCpy(sub.samples, sub.best.residual, sub.best.order);
int* data = sub.samples + sub.best.order; int* data = sub.samples + sub.best.order;
int* residual = sub.best.residual + sub.best.order; int* residual = sub.samples + sub.best.order;
int data_len = frame.blocksize - sub.best.order; int data_len = frame.blocksize - sub.best.order;
int s0, s1, s2; int s0, s1, s2;
switch (sub.best.order) switch (sub.best.order)
{ {
case 0: case 0:
AudioSamples.MemCpy(data, residual, data_len); //AudioSamples.MemCpy(data, residual, data_len);
break; break;
case 1: case 1:
s1 = data[-1]; s1 = data[-1];
@@ -543,10 +638,12 @@ namespace CUETools.Codecs.FLAKE
{ {
for (int i = sub.best.order; i > 0; i--) for (int i = sub.best.order; i > 0; i--)
csum += (ulong)Math.Abs(coefs[i - 1]); csum += (ulong)Math.Abs(coefs[i - 1]);
if ((csum << sub.obits) >= 1UL << 32) //if (frame.subframes[ch].best.order <= 12 && (csum << sub.obits) < 1UL << 32)
lpc.decode_residual_long(sub.best.residual, sub.samples, frame.blocksize, sub.best.order, coefs, sub.best.shift); // return;
if ((csum << sub.obits) >= 1UL << 32)
lpc.decode_residual_long(sub.samples, sub.samples, frame.blocksize, sub.best.order, coefs, sub.best.shift);
else else
lpc.decode_residual(sub.best.residual, sub.samples, frame.blocksize, sub.best.order, coefs, sub.best.shift); lpc.decode_residual(sub.samples, frame.blocksize, sub.best.order, coefs, sub.best.shift);
} }
} }
@@ -557,16 +654,16 @@ namespace CUETools.Codecs.FLAKE
switch (frame.subframes[ch].best.type) switch (frame.subframes[ch].best.type)
{ {
case SubframeType.Constant: case SubframeType.Constant:
AudioSamples.MemSet(frame.subframes[ch].samples, frame.subframes[ch].best.residual[0], frame.blocksize); AudioSamples.MemSet(frame.subframes[ch].samples, frame.subframes[ch].samples[0], frame.blocksize);
break; break;
case SubframeType.Verbatim: case SubframeType.Verbatim:
AudioSamples.MemCpy(frame.subframes[ch].samples, frame.subframes[ch].best.residual, frame.blocksize); //AudioSamples.MemCpy(frame.subframes[ch].samples, frame.subframes[ch].best.residual, frame.blocksize);
break; break;
case SubframeType.Fixed: case SubframeType.Fixed:
restore_samples_fixed(frame, ch); restore_samples_fixed(frame, ch);
break; break;
case SubframeType.LPC: case SubframeType.LPC:
restore_samples_lpc(frame, ch); restore_samples_lpc(frame, ch);
break; break;
} }
if (frame.subframes[ch].wbits != 0) if (frame.subframes[ch].wbits != 0)

42
CUETools.Codecs/BitReader.cs
View File

@@ -71,11 +71,11 @@ namespace CUETools.Codecs
#endregion #endregion
private byte* buffer_m; private byte* buffer_m;
private byte* bptr_m; public byte* bptr_m;
private int buffer_len_m; public int buffer_len_m;
private int have_bits_m; public int have_bits_m;
private ulong cache_m; public ulong cache_m;
private ushort crc16_m; public ushort crc16_m;
public int Position public int Position
{ {
@@ -296,6 +296,38 @@ namespace CUETools.Codecs
return v; return v;
} }
public void read_int_block(int n, int k, int* r)
{
fill();
byte* bptr = bptr_m;
int have_bits = have_bits_m;
ulong cache = cache_m;
ushort crc = crc16_m;
fixed (ushort* t = Crc16.table)
{
for (int i = n; i > 0; i--)
{
while (have_bits < 56)
{
have_bits += 8;
byte b = *(bptr++);
cache |= (ulong)b << (64 - have_bits);
crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ b]);
}
int res = (int)((long)cache >> 64 - k);
cache <<= k;
have_bits -= k;
*(r++) = res;
}
}
have_bits_m = have_bits;
cache_m = cache;
bptr_m = bptr;
crc16_m = crc;
}
public void read_rice_block(int n, int k, int* r) public void read_rice_block(int n, int k, int* r)
{ {
fill(); fill();

190
CUETools.Codecs/LPC.cs
View File

@@ -755,160 +755,170 @@ namespace CUETools.Codecs
} }
public static unsafe void public static unsafe void
decode_residual(int* res, int* smp, int n, int order, decode_residual(int* smp, int n, int order,
int* coefs, int shift) int* coefs, int shift)
{ {
for (int i = 0; i < order; i++)
smp[i] = res[i];
int* s = smp; int* s = smp;
int* r = res + order; int* cc = stackalloc int[12];
int c0 = coefs[0]; for (int i = 0; i < 12; i++)
int c1 = coefs[1]; cc[i] = 0;
switch (order) if (order <= 12)
{
for (int i = 0; i < order; i++)
cc[i] = coefs[order - 1 - i];
}
switch (order)
{ {
case 1: case 1:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int pred = c0 * *(s++); int pred = *cc * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
} }
break; break;
case 2: case 2:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int pred = c1 * *(s++) + c0 * *(s++); int* co = cc;
*(s--) = *(r++) + (pred >> shift); int pred =
*(co++) * *(s++) + *co * *(s++);
*(s--) += pred >> shift;
} }
break; break;
case 3: case 3:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *co * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 2; s -= 2;
} }
break; break;
case 4: case 4:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co++) * *(s++) + *co * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 3; s -= 3;
} }
break; break;
case 5: case 5:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co) * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 4; s -= 4;
} }
break; break;
case 6: case 6:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co++) * *(s++) + *(co++) * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 5; s -= 5;
} }
break; break;
case 7: case 7:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co++) * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 6; s -= 6;
} }
break; break;
case 8: case 8:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co++) * *(s++) + *(co++) * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 7; s -= 7;
} }
break; break;
case 9: case 9:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co++) * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 8; s -= 8;
} }
break; break;
case 10: case 10:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co++) * *(s++) + *(co++) * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 9; s -= 9;
} }
break; break;
case 11: case 11:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co++) * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
s -= 10; s -= 10;
} }
break; break;
case 12: case 12:
for (int i = n - order; i > 0; i--) for (int i = n - order; i > 0; i--)
{ {
int* co = coefs + order - 1; int* co = cc;
int pred = int pred =
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
*(co--) * *(s++) + *(co--) * *(s++) + *(co++) * *(s++) + *(co++) * *(s++) +
c1 * *(s++) + c0 * *(s++); *(co++) * *(s++) + *(co++) * *(s++);
*s = *(r++) + (pred >> shift); // cc[00] * s[00] + cc[01] * s[01]
s -= 11; //+ cc[02] * s[02] + cc[03] * s[03]
//+ cc[04] * s[04] + cc[05] * s[05]
//+ cc[06] * s[06] + cc[07] * s[07]
//+ cc[08] * s[08] + cc[09] * s[09]
//+ cc[10] * s[10] + cc[11] * s[11];
*s += pred >> shift;
s -= 11;
} }
break; break;
default: default:
@@ -926,10 +936,10 @@ namespace CUETools.Codecs
pred += coefs[4] * *(s++); pred += coefs[4] * *(s++);
pred += coefs[3] * *(s++); pred += coefs[3] * *(s++);
pred += coefs[2] * *(s++); pred += coefs[2] * *(s++);
pred += c1 * *(s++); pred += coefs[1] * *(s++);
pred += c0 * *(s++); pred += coefs[0] * *(s++);
*s = *(r++) + (pred >> shift); *s += pred >> shift;
} }
break; break;
} }
} }