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

Flake optimizations

Browse Source
This commit is contained in:
Grigory Chudov
2014-09-19 22:01:20 -04:00
parent 3572745968
commit fac9689155
4 changed files with 138 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
CUETools.Codecs.FLACCL/FLACCLWriter.cs
View File

@@ -1360,16 +1360,18 @@ namespace CUETools.Codecs.FLACCL
case SubframeType.LPC: case SubframeType.LPC:
if (!task.UseGPUOnly) if (!task.UseGPUOnly)
{ {
int pmin = get_max_p_order(m_settings.MinPartitionOrder, task.frame.blocksize, task.frame.subframes[ch].best.order);
int pmax = get_max_p_order(m_settings.MaxPartitionOrder, task.frame.blocksize, task.frame.subframes[ch].best.order);
ulong* sums = stackalloc ulong[(pmax + 1) * Flake.MAX_PARTITIONS];
fixed (int* coefs = task.frame.subframes[ch].best.coefs) fixed (int* coefs = task.frame.subframes[ch].best.coefs)
{ {
if (Settings.PCM.BitsPerSample > 16) if (Settings.PCM.BitsPerSample > 16)
lpc.encode_residual_long(task.frame.subframes[ch].best.residual, task.frame.subframes[ch].samples, task.frame.blocksize, task.frame.subframes[ch].best.order, coefs, task.frame.subframes[ch].best.shift); lpc.encode_residual_long(task.frame.subframes[ch].best.residual, task.frame.subframes[ch].samples, task.frame.blocksize, task.frame.subframes[ch].best.order, coefs, task.frame.subframes[ch].best.shift, sums + pmax * Flake.MAX_PARTITIONS, pmax);
else else
lpc.encode_residual(task.frame.subframes[ch].best.residual, task.frame.subframes[ch].samples, task.frame.blocksize, task.frame.subframes[ch].best.order, coefs, task.frame.subframes[ch].best.shift); lpc.encode_residual(task.frame.subframes[ch].best.residual, task.frame.subframes[ch].samples, task.frame.blocksize, task.frame.subframes[ch].best.order, coefs, task.frame.subframes[ch].best.shift, sums + pmax * Flake.MAX_PARTITIONS, pmax);
} }
int pmin = get_max_p_order(m_settings.MinPartitionOrder, task.frame.blocksize, task.frame.subframes[ch].best.order);
int pmax = get_max_p_order(m_settings.MaxPartitionOrder, task.frame.blocksize, task.frame.subframes[ch].best.order);
calc_rice_params(task.frame.subframes[ch].best.rc, pmin, pmax, task.frame.subframes[ch].best.residual, (uint)task.frame.blocksize, (uint)task.frame.subframes[ch].best.order, Settings.PCM.BitsPerSample > 16 ? 1 : 0); calc_rice_params(task.frame.subframes[ch].best.rc, pmin, pmax, task.frame.subframes[ch].best.residual, (uint)task.frame.blocksize, (uint)task.frame.subframes[ch].best.order, Settings.PCM.BitsPerSample > 16 ? 1 : 0);
} }
break; break;

44
CUETools.Codecs.FLAKE/FlakeWriter.cs
View File

@@ -1156,12 +1156,12 @@ new int[] { // 30
fixed (int* coefs = frame.current.coefs) fixed (int* coefs = frame.current.coefs)
{ {
if ((csum << frame.subframes[ch].obits) >= 1UL << 32) if ((csum << frame.subframes[ch].obits) >= 1UL << 32)
lpc.encode_residual_long(frame.current.residual, frame.subframes[ch].samples, frame.blocksize, frame.current.order, coefs, frame.current.shift); lpc.encode_residual_long(frame.current.residual, frame.subframes[ch].samples, frame.blocksize, frame.current.order, coefs, frame.current.shift, sums + pmax * Flake.MAX_PARTITIONS, pmax);
else else
lpc.encode_residual(frame.current.residual, frame.subframes[ch].samples, frame.blocksize, frame.current.order, coefs, frame.current.shift); lpc.encode_residual(frame.current.residual, frame.subframes[ch].samples, frame.blocksize, frame.current.order, coefs, frame.current.shift, sums + pmax * Flake.MAX_PARTITIONS, pmax);
} }
var cur_size = calc_rice_params(frame.current.rc, pmin, pmax, frame.current.residual, (uint)frame.blocksize, (uint)frame.current.order, Settings.PCM.BitsPerSample); var cur_size = calc_rice_params_sums(frame.current.rc, pmin, pmax, sums, (uint)frame.blocksize, (uint)frame.current.order, Settings.PCM.BitsPerSample);
frame.current.size = (uint)(frame.current.order * frame.subframes[ch].obits + 4 + 5 + frame.current.order * frame.current.cbits + 6 + (int)cur_size); frame.current.size = (uint)(frame.current.order * frame.subframes[ch].obits + 4 + 5 + frame.current.order * frame.current.cbits + 6 + (int)cur_size);
if (frame.current.size < best_size) if (frame.current.size < best_size)
@@ -1261,6 +1261,10 @@ new int[] { // 30
frame.current.window = iWindow; frame.current.window = iWindow;
frame.current.cbits = (int)cbits; frame.current.cbits = (int)cbits;
int pmax = get_max_p_order(m_settings.MaxPartitionOrder, frame.blocksize, frame.current.order);
int pmin = Math.Min(m_settings.MinPartitionOrder, pmax);
ulong* sums = stackalloc ulong[(pmax + 1) * Flake.MAX_PARTITIONS];
ulong csum = 0;
fixed (int* coefs = frame.current.coefs) fixed (int* coefs = frame.current.coefs)
{ {
lpc.quantize_lpc_coefs(lpcs + (frame.current.order - 1) * lpc.MAX_LPC_ORDER, lpc.quantize_lpc_coefs(lpcs + (frame.current.order - 1) * lpc.MAX_LPC_ORDER,
@@ -1269,36 +1273,16 @@ new int[] { // 30
if (frame.current.shift < 0 || frame.current.shift > 15) if (frame.current.shift < 0 || frame.current.shift > 15)
throw new Exception("negative shift"); throw new Exception("negative shift");
ulong csum = 0;
for (int i = frame.current.order; i > 0; i--) for (int i = frame.current.order; i > 0; i--)
csum += (ulong)Math.Abs(coefs[i - 1]); csum += (ulong)Math.Abs(coefs[i - 1]);
if ((csum << frame.subframes[ch].obits) >= 1UL << 32) if ((csum << frame.subframes[ch].obits) >= 1UL << 32)
lpc.encode_residual_long(frame.current.residual, frame.subframes[ch].samples, frame.blocksize, frame.current.order, coefs, frame.current.shift); lpc.encode_residual_long(frame.current.residual, frame.subframes[ch].samples, frame.blocksize, frame.current.order, coefs, frame.current.shift, sums + pmax * Flake.MAX_PARTITIONS, pmax);
else else
lpc.encode_residual(frame.current.residual, frame.subframes[ch].samples, frame.blocksize, frame.current.order, coefs, frame.current.shift); lpc.encode_residual(frame.current.residual, frame.subframes[ch].samples, frame.blocksize, frame.current.order, coefs, frame.current.shift, sums + pmax * Flake.MAX_PARTITIONS, pmax);
} }
int pmax = get_max_p_order(m_settings.MaxPartitionOrder, frame.blocksize, frame.current.order); uint best_size = calc_rice_params_sums(frame.current.rc, pmin, pmax, sums, (uint)frame.blocksize, (uint)frame.current.order, Settings.PCM.BitsPerSample);
int pmin = Math.Min(m_settings.MinPartitionOrder, pmax);
uint best_size = calc_rice_params(frame.current.rc, pmin, pmax, frame.current.residual, (uint)frame.blocksize, (uint)frame.current.order, Settings.PCM.BitsPerSample);
// not working
//for (int o = 1; o <= frame.current.order; o++)
//{
// if (frame.current.coefs[o - 1] > -(1 << frame.current.shift))
// {
// for (int i = o; i < frame.blocksize; i++)
// frame.current.residual[i] += frame.subframes[ch].samples[i - o] >> frame.current.shift;
// frame.current.coefs[o - 1]--;
// uint new_size = calc_rice_params(ref frame.current.rc, pmin, pmax, frame.current.residual, (uint)frame.blocksize, (uint)frame.current.order);
// if (new_size > best_size)
// {
// for (int i = o; i < frame.blocksize; i++)
// frame.current.residual[i] -= frame.subframes[ch].samples[i - o] >> frame.current.shift;
// frame.current.coefs[o - 1]++;
// }
// }
//}
frame.current.size = (uint)(frame.current.order * frame.subframes[ch].obits + 4 + 5 + frame.current.order * (int)cbits + 6 + (int)best_size); frame.current.size = (uint)(frame.current.order * frame.subframes[ch].obits + 4 + 5 + frame.current.order * (int)cbits + 6 + (int)best_size);
frame.ChooseBestSubframe(ch); frame.ChooseBestSubframe(ch);
//if (frame.current.size >= frame.subframes[ch].best.size) //if (frame.current.size >= frame.subframes[ch].best.size)
@@ -1522,7 +1506,7 @@ new int[] { // 30
{ {
case OrderMethod.Akaike: case OrderMethod.Akaike:
//lpc_ctx.SortOrdersAkaike(frame.blocksize, eparams.estimation_depth, max_order, 7.1, 0.0); //lpc_ctx.SortOrdersAkaike(frame.blocksize, eparams.estimation_depth, max_order, 7.1, 0.0);
lpc_ctx.SortOrdersAkaike(frame.blocksize, eparams.estimation_depth, min_order, max_order, 4.5, 0.0); lpc_ctx.SortOrdersAkaike(frame.blocksize, eparams.estimation_depth, min_order, max_order, 4.5, 0);
break; break;
default: default:
throw new Exception("unknown order method"); throw new Exception("unknown order method");
@@ -2175,12 +2159,16 @@ new int[] { // 30
{ {
frame2.InitSize(frame.blocksize / 2, true); frame2.InitSize(frame.blocksize / 2, true);
frame2.window_buffer = frame.window_buffer + frame.blocksize; frame2.window_buffer = frame.window_buffer + frame.blocksize;
frame2.nSeg++; frame2.nSeg = frame.nSeg + 1;
frame2.current.residual = r + tumbler * 5 * Flake.MAX_BLOCKSIZE; frame2.current.residual = r + tumbler * 5 * Flake.MAX_BLOCKSIZE;
for (int ch = 0; ch < 4; ch++) for (int ch = 0; ch < 4; ch++)
frame2.subframes[ch].Init(frame.subframes[ch].samples, frame2.current.residual + (ch + 1) * frame2.blocksize, frame2.subframes[ch].Init(frame.subframes[ch].samples, frame2.current.residual + (ch + 1) * frame2.blocksize,
frame.subframes[ch].obits + frame.subframes[ch].wbits, frame.subframes[ch].wbits); frame.subframes[ch].obits + frame.subframes[ch].wbits, frame.subframes[ch].wbits);
estimate_frame(frame2, true); estimate_frame(frame2, true);
//measure_frame_size(frame2, true);
//frame2.ChooseSubframes();
//encode_estimated_frame(frame2);
//uint fs2 = measure_frame_size(frame2, false);
uint fs2 = measure_frame_size(frame2, true); uint fs2 = measure_frame_size(frame2, true);
uint fs3 = fs2; uint fs3 = fs2;
if (eparams.variable_block_size == 2 || eparams.variable_block_size == 4) if (eparams.variable_block_size == 2 || eparams.variable_block_size == 4)

27
CUETools.Codecs/BitWriter.cs
View File

@@ -295,8 +295,7 @@ namespace CUETools.Codecs
return; return;
} }
#endif #endif
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bit_buf >> 56)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bit_buf >> 56))]);
*(buf++) = (byte)(bit_buf >> 56);
bit_buf <<= 8; bit_buf <<= 8;
bits -= 8; bits -= 8;
} }
@@ -320,23 +319,15 @@ namespace CUETools.Codecs
} }
#endif #endif
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bb >> 56)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 56))]);
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bb >> 48)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 48))]);
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bb >> 40)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 40))]);
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bb >> 32)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 32))]);
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bb >> 24)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 24))]);
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bb >> 16)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 16))]);
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bb >> 8)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb >> 8))]);
crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (byte)(bb)]); crc16 = (ushort)((crc16 << 8) ^ crc16_t[(crc16 >> 8) ^ (*(buf++) = (byte)(bb))]);
*(buf++) = (byte)(bb >> 56);
*(buf++) = (byte)(bb >> 48);
*(buf++) = (byte)(bb >> 40);
*(buf++) = (byte)(bb >> 32);
*(buf++) = (byte)(bb >> 24);
*(buf++) = (byte)(bb >> 16);
*(buf++) = (byte)(bb >> 8);
*(buf++) = (byte)(bb);
bit_left += 64 - bits; bit_left += 64 - bits;
bit_buf = (val << bit_left - 1) << 1; bit_buf = (val << bit_left - 1) << 1;
} }

327
CUETools.Codecs/LPC.cs
View File

@@ -515,80 +515,82 @@ namespace CUETools.Codecs
shift = sh; shift = sh;
} }
public static unsafe void private static unsafe ulong
encode_residual(int* res, int* smp, int n, int order, encode_residual_partition(int* s, int* r, int* seg_end, int* coefs, int shift, int order)
int* coefs, int shift)
{ {
for (int i = 0; i < order; i++) ulong sum = 0ul;
res[i] = smp[i];
int* s = smp;
int* r = res + order;
int c0 = coefs[0]; int c0 = coefs[0];
int c1 = coefs[1]; int c1 = coefs[1];
switch (order) switch (order)
{ {
case 1: case 1:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int pred = c0 * *(s++); int pred = c0 * *(s++);
*(r++) = *s - (pred >> shift); //*(r++) = *s - (pred >> shift);
int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
} }
break; break;
case 2: case 2:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int pred = c1 * *(s++); int pred = c1 * *(s++);
pred += c0 * *(s++); pred += c0 * *(s++);
*(r++) = *(s--) - (pred >> shift); int d = *(r++) = *(s--) - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
} }
break; break;
case 3: case 3:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int pred = coefs[2] * *(s++) + int pred = coefs[2] * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 2; s -= 2;
} }
break; break;
case 4: case 4:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 3; s -= 3;
} }
break; break;
case 5: case 5:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 4; s -= 4;
} }
break; break;
case 6: case 6:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 5; s -= 5;
} }
break; break;
case 7: case 7:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
@@ -596,12 +598,13 @@ namespace CUETools.Codecs
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 6; s -= 6;
} }
break; break;
case 8: case 8:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
@@ -609,12 +612,13 @@ namespace CUETools.Codecs
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 7; s -= 7;
} }
break; break;
case 9: case 9:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
@@ -623,12 +627,13 @@ namespace CUETools.Codecs
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 8; s -= 8;
} }
break; break;
case 10: case 10:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
@@ -637,12 +642,13 @@ namespace CUETools.Codecs
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 9; s -= 9;
} }
break; break;
case 11: case 11:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
@@ -652,12 +658,13 @@ namespace CUETools.Codecs
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 10; s -= 10;
} }
break; break;
case 12: case 12:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
int* c = coefs + order - 1; int* c = coefs + order - 1;
int pred = int pred =
@@ -667,14 +674,14 @@ namespace CUETools.Codecs
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 11; s -= 11;
} }
break; break;
default: default:
for (int i = order; i < n; i++) while (s < seg_end)
{ {
s = smp + i - order;
int pred = 0; int pred = 0;
int* c = coefs + order - 1; int* c = coefs + order - 1;
int* c11 = coefs + 11; int* c11 = coefs + 11;
@@ -687,75 +694,99 @@ namespace CUETools.Codecs
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++); c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift); int d = *(r++) = *s - (pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= order - 1;
} }
break; break;
} }
return sum;
} }
public static unsafe void public static unsafe void
encode_residual_long(int* res, int* smp, int n, int order, encode_residual(int* res, int* smp, int n, int order,
int* coefs, int shift) int* coefs, int shift, ulong* sums, int pmax)
{ {
for (int i = 0; i < order; i++) for (int i = 0; i < order; i++)
res[i] = smp[i]; res[i] = smp[i];
int* s = smp; int* s = smp;
int* s_end = smp + n - order;
int* seg_end = s + (n >> pmax) - order;
int* r = res + order; int* r = res + order;
while (s < s_end)
{
*(sums++) = encode_residual_partition(s, r, seg_end, coefs, shift, order);
r += seg_end - s;
s = seg_end;
seg_end += n >> pmax;
}
}
private static unsafe ulong
encode_residual_long_partition(int* s, int* r, int* seg_end, int* coefs, int shift, int order)
{
ulong sum = 0ul;
int c0 = coefs[0]; int c0 = coefs[0];
int c1 = coefs[1]; int c1 = coefs[1];
switch (order) switch (order)
{ {
case 1: case 1:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
long pred = c0 * (long)*(s++); long pred = c0 * (long)*(s++);
*(r++) = *s - (int)(pred >> shift); int d = *(r++) = *s - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
} }
break; break;
case 2: case 2:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
long pred = c1 * (long)*(s++); long pred = c1 * (long)*(s++);
pred += c0 * (long)*(s++); pred += c0 * (long)*(s++);
*(r++) = *(s--) - (int)(pred >> shift); int d = *(r++) = *(s--) - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
} }
break; break;
case 3: case 3:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
long pred = coefs[2] * (long)*(s++); long pred = coefs[2] * (long)*(s++);
pred += c1 * (long)*(s++); pred += c1 * (long)*(s++);
pred += c0 * (long)*(s++); pred += c0 * (long)*(s++);
*(r++) = *s - (int)(pred >> shift); *(r++) = *s - (int)(pred >> shift);
int d = *(r++) = *s - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 2; s -= 2;
} }
break; break;
case 4: case 4:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
long pred = coefs[3] * (long)*(s++); long pred = coefs[3] * (long)*(s++);
pred += coefs[2] * (long)*(s++); pred += coefs[2] * (long)*(s++);
pred += c1 * (long)*(s++); pred += c1 * (long)*(s++);
pred += c0 * (long)*(s++); pred += c0 * (long)*(s++);
*(r++) = *s - (int)(pred >> shift); int d = *(r++) = *s - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 3; s -= 3;
} }
break; break;
case 5: case 5:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
long pred = coefs[4] * (long)*(s++); long pred = coefs[4] * (long)*(s++);
pred += coefs[3] * (long)*(s++); pred += coefs[3] * (long)*(s++);
pred += coefs[2] * (long)*(s++); pred += coefs[2] * (long)*(s++);
pred += c1 * (long)*(s++); pred += c1 * (long)*(s++);
pred += c0 * (long)*(s++); pred += c0 * (long)*(s++);
*(r++) = *s - (int)(pred >> shift); int d = *(r++) = *s - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 4; s -= 4;
} }
break; break;
case 6: case 6:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
long pred = coefs[5] * (long)*(s++); long pred = coefs[5] * (long)*(s++);
pred += coefs[4] * (long)*(s++); pred += coefs[4] * (long)*(s++);
@@ -763,12 +794,13 @@ namespace CUETools.Codecs
pred += coefs[2] * (long)*(s++); pred += coefs[2] * (long)*(s++);
pred += c1 * (long)*(s++); pred += c1 * (long)*(s++);
pred += c0 * (long)*(s++); pred += c0 * (long)*(s++);
*(r++) = *s - (int)(pred >> shift); int d = *(r++) = *s - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 5; s -= 5;
} }
break; break;
case 7: case 7:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
long pred = coefs[6] * (long)*(s++); long pred = coefs[6] * (long)*(s++);
pred += coefs[5] * (long)*(s++); pred += coefs[5] * (long)*(s++);
@@ -777,12 +809,13 @@ namespace CUETools.Codecs
pred += coefs[2] * (long)*(s++); pred += coefs[2] * (long)*(s++);
pred += c1 * (long)*(s++); pred += c1 * (long)*(s++);
pred += c0 * (long)*(s++); pred += c0 * (long)*(s++);
*(r++) = *s - (int)(pred >> shift); int d = *(r++) = *s - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 6; s -= 6;
} }
break; break;
case 8: case 8:
for (int i = n - order; i > 0; i--) while (s < seg_end)
{ {
long pred = coefs[7] * (long)*(s++); long pred = coefs[7] * (long)*(s++);
pred += coefs[6] * (long)*(s++); pred += coefs[6] * (long)*(s++);
@@ -792,14 +825,14 @@ namespace CUETools.Codecs
pred += coefs[2] * (long)*(s++); pred += coefs[2] * (long)*(s++);
pred += c1 * (long)*(s++); pred += c1 * (long)*(s++);
pred += c0 * (long)*(s++); pred += c0 * (long)*(s++);
*(r++) = *s - (int)(pred >> shift); int d = *(r++) = *s - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= 7; s -= 7;
} }
break; break;
default: default:
for (int i = order; i < n; i++) while (s < seg_end)
{ {
s = smp + i - order;
long pred = 0; long pred = 0;
int* co = coefs + order - 1; int* co = coefs + order - 1;
int* c7 = coefs + 7; int* c7 = coefs + 7;
@@ -813,184 +846,32 @@ namespace CUETools.Codecs
pred += coefs[2] * (long)*(s++); pred += coefs[2] * (long)*(s++);
pred += c1 * (long)*(s++); pred += c1 * (long)*(s++);
pred += c0 * (long)*(s++); pred += c0 * (long)*(s++);
*(r++) = *s - (int)(pred >> shift); int d = *(r++) = *s - (int)(pred >> shift);
sum += (uint)((d << 1) ^ (d >> 31));
s -= order - 1;
} }
break; break;
} }
return sum;
} }
public static unsafe void public static unsafe void
encode_residual2(int* res, int* smp, int n, int order, encode_residual_long(int* res, int* smp, int n, int order,
int* coefs, int shift) int* coefs, int shift, ulong* sums, int pmax)
{ {
for (int i = 0; i < order; i++)
res[i] = smp[i];
int* s = smp; int* s = smp;
int* r = res; int* s_end = smp + n - order;
int c0 = coefs[0]; int* seg_end = s + (n >> pmax) - order;
int c1 = coefs[1]; int* r = res + order;
switch (order) while (s < s_end)
{ {
case 1: *(sums++) = encode_residual_long_partition(s, r, seg_end, coefs, shift, order);
for (int i = n - order; i > 0; i--) r += seg_end - s;
{ s = seg_end;
int pred = c0 * *(s++); seg_end += n >> pmax;
*(r++) = *s - (pred >> shift);
}
break;
case 2:
for (int i = n - order; i > 0; i--)
{
int pred = c1 * *(s++);
pred += c0 * *(s++);
*(r++) = *(s--) - (pred >> shift);
}
break;
case 3:
for (int i = n - order; i > 0; i--)
{
int pred = coefs[2] * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 2;
}
break;
case 4:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 3;
}
break;
case 5:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 4;
}
break;
case 6:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 5;
}
break;
case 7:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 6;
}
break;
case 8:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 7;
}
break;
case 9:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 8;
}
break;
case 10:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 9;
}
break;
case 11:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 10;
}
break;
case 12:
for (int i = n - order; i > 0; i--)
{
int* c = coefs + order - 1;
int pred =
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
s -= 11;
}
break;
default:
for (int i = order; i < n; i++)
{
s = smp + i - order;
int pred = 0;
int* c = coefs + order - 1;
int* c11 = coefs + 11;
while (c > c11)
pred += *(c--) * *(s++);
pred +=
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
*(c--) * *(s++) + *(c--) * *(s++) +
c1 * *(s++) + c0 * *(s++);
*(r++) = *s - (pred >> shift);
}
break;
} }
} }