sm64pc/tools/sdk-tools/adpcm/vencode.c

237 lines
7.1 KiB
C
Raw Normal View History

2020-05-05 12:15:53 +00:00
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "vadpcm.h"
void vencodeframe(FILE *ofile, s16 *inBuffer, s32 *state, s32 ***coefTable, s32 order, s32 npredictors, s32 nsam)
{
s16 ix[16];
s32 prediction[16];
s32 inVector[16];
s32 saveState[16];
s32 optimalp;
s32 scale;
s32 llevel;
s32 ulevel;
s32 i;
s32 j;
s32 k;
s32 ie[16];
s32 nIter;
s32 max;
s32 cV;
s32 maxClip;
u8 header;
u8 c;
f32 e[16];
f32 se;
f32 min;
// We are only given 'nsam' samples; pad with zeroes to 16.
for (i = nsam; i < 16; i++)
{
inBuffer[i] = 0;
}
llevel = -8;
ulevel = -llevel - 1;
// Determine the best-fitting predictor.
min = 1e30;
optimalp = 0;
for (k = 0; k < npredictors; k++)
{
// Copy over the last 'order' samples from the previous output.
for (i = 0; i < order; i++)
{
inVector[i] = state[16 - order + i];
}
// For 8 samples...
for (i = 0; i < 8; i++)
{
// Compute a prediction based on 'order' values from the old state,
// plus previous errors in this chunk, as an inner product with the
// coefficient table.
prediction[i] = inner_product(order + i, coefTable[k][i], inVector);
// Record the error in inVector (thus, its first 'order' samples
// will contain actual values, the rest will be error terms), and
// in floating point form in e (for no particularly good reason).
inVector[i + order] = inBuffer[i] - prediction[i];
e[i] = (f32) inVector[i + order];
}
// For the next 8 samples, start with 'order' values from the end of
// the previous 8-sample chunk of inBuffer. (The code is equivalent to
// inVector[i] = inBuffer[8 - order + i].)
for (i = 0; i < order; i++)
{
inVector[i] = prediction[8 - order + i] + inVector[8 + i];
}
// ... and do the same thing as before to get predictions.
for (i = 0; i < 8; i++)
{
prediction[8 + i] = inner_product(order + i, coefTable[k][i], inVector);
inVector[i + order] = inBuffer[8 + i] - prediction[8 + i];
e[8 + i] = (f32) inVector[i + order];
}
// Compute the L2 norm of the errors; the lowest norm decides which
// predictor to use.
se = 0.0f;
for (j = 0; j < 16; j++)
{
se += e[j] * e[j];
}
if (se < min)
{
min = se;
optimalp = k;
}
}
// Do exactly the same thing again, for real.
for (i = 0; i < order; i++)
{
inVector[i] = state[16 - order + i];
}
for (i = 0; i < 8; i++)
{
prediction[i] = inner_product(order + i, coefTable[optimalp][i], inVector);
inVector[i + order] = inBuffer[i] - prediction[i];
e[i] = (f32) inVector[i + order];
}
for (i = 0; i < order; i++)
{
inVector[i] = prediction[8 - order + i] + inVector[8 + i];
}
for (i = 0; i < 8; i++)
{
prediction[8 + i] = inner_product(order + i, coefTable[optimalp][i], inVector);
inVector[i + order] = inBuffer[8 + i] - prediction[8 + i];
e[8 + i] = (f32) inVector[i + order];
}
// Clamp the errors to 16-bit signed ints, and put them in ie.
clamp(16, e, ie, 16);
// Find a value with highest absolute value.
// @bug If this first finds -2^n and later 2^n, it should set 'max' to the
// latter, which needs a higher value for 'scale'.
max = 0;
for (i = 0; i < 16; i++)
{
if (fabs(ie[i]) > fabs(max))
{
max = ie[i];
}
}
// Compute which power of two we need to scale down by in order to make
// all values representable as 4-bit signed integers (i.e. be in [-8, 7]).
// The worst-case 'max' is -2^15, so this will be at most 12.
for (scale = 0; scale <= 12; scale++)
{
if (max <= ulevel && max >= llevel)
{
goto out;
}
max /= 2;
}
out:;
for (i = 0; i < 16; i++)
{
saveState[i] = state[i];
}
// Try with the computed scale, but if it turns out we don't fit in 4 bits
// (if some |cV| >= 2), use scale + 1 instead (i.e. downscaling by another
// factor of 2).
scale--;
nIter = 0;
do
{
nIter++;
maxClip = 0;
scale++;
if (scale > 12)
{
scale = 12;
}
// Copy over the last 'order' samples from the previous output.
for (i = 0; i < order; i++)
{
inVector[i] = saveState[16 - order + i];
}
// For 8 samples...
for (i = 0; i < 8; i++)
{
// Compute a prediction based on 'order' values from the old state,
// plus previous *quantized* errors in this chunk (because that's
// all the decoder will have available).
prediction[i] = inner_product(order + i, coefTable[optimalp][i], inVector);
// Compute the error, and divide it by 2^scale, rounding to the
// nearest integer. This should ideally result in a 4-bit integer.
se = (f32) inBuffer[i] - (f32) prediction[i];
ix[i] = qsample(se, 1 << scale);
// Clamp the error to a 4-bit signed integer, and record what delta
// was needed for that.
cV = (s16) clip(ix[i], llevel, ulevel) - ix[i];
if (maxClip < abs(cV))
{
maxClip = abs(cV);
}
ix[i] += cV;
// Record the quantized error in inVector for later predictions,
// and the quantized (decoded) output in state (for use in the next
// batch of 8 samples).
inVector[i + order] = ix[i] * (1 << scale);
state[i] = prediction[i] + inVector[i + order];
}
// Copy over the last 'order' decoded samples from the above chunk.
for (i = 0; i < order; i++)
{
inVector[i] = state[8 - order + i];
}
// ... and do the same thing as before.
for (i = 0; i < 8; i++)
{
prediction[8 + i] = inner_product(order + i, coefTable[optimalp][i], inVector);
se = (f32) inBuffer[8 + i] - (f32) prediction[8 + i];
ix[8 + i] = qsample(se, 1 << scale);
cV = (s16) clip(ix[8 + i], llevel, ulevel) - ix[8 + i];
if (maxClip < abs(cV))
{
maxClip = abs(cV);
}
ix[8 + i] += cV;
inVector[i + order] = ix[8 + i] * (1 << scale);
state[8 + i] = prediction[8 + i] + inVector[i + order];
}
}
while (maxClip >= 2 && nIter < 2);
// The scale, the predictor index, and the 16 computed outputs are now all
// 4-bit numbers. Write them out as 1 + 8 bytes.
header = (scale << 4) | (optimalp & 0xf);
fwrite(&header, 1, 1, ofile);
for (i = 0; i < 16; i += 2)
{
c = (ix[i] << 4) | (ix[i + 1] & 0xf);
fwrite(&c, 1, 1, ofile);
}
}