sm64pc/tools/audiofile-0.3.6/libaudiofile/modules/MSADPCM.cpp
2020-05-07 20:21:22 +02:00

453 lines
11 KiB
C++

/*
Audio File Library
Copyright (C) 2010-2013, Michael Pruett <michael@68k.org>
Copyright (C) 2001, Silicon Graphics, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301 USA
*/
/*
This module implements Microsoft ADPCM compression.
*/
#include "config.h"
#include "MSADPCM.h"
#include <assert.h>
#include <cstdlib>
#include <limits>
#include <string.h>
#include "BlockCodec.h"
#include "Compiler.h"
#include "File.h"
#include "Track.h"
#include "afinternal.h"
#include "audiofile.h"
#include "byteorder.h"
#include "util.h"
#include "../pcm.h"
struct ms_adpcm_state
{
uint8_t predictorIndex;
int delta;
int16_t sample1, sample2;
ms_adpcm_state()
{
predictorIndex = 0;
delta = 16;
sample1 = 0;
sample2 = 0;
}
};
class MSADPCM : public BlockCodec
{
public:
static MSADPCM *createDecompress(Track *, File *, bool canSeek,
bool headerless, AFframecount *chunkFrames);
static MSADPCM *createCompress(Track *, File *, bool canSeek,
bool headerless, AFframecount *chunkFrames);
virtual ~MSADPCM();
bool initializeCoefficients();
virtual const char *name() const OVERRIDE
{
return mode() == Compress ? "ms_adpcm_compress" : "ms_adpcm_decompress";
}
virtual void describe() OVERRIDE;
private:
// m_coefficients is an array of m_numCoefficients ADPCM coefficient pairs.
int m_numCoefficients;
int16_t m_coefficients[256][2];
ms_adpcm_state *m_state;
MSADPCM(Mode mode, Track *track, File *fh, bool canSeek);
int decodeBlock(const uint8_t *encoded, int16_t *decoded) OVERRIDE;
int encodeBlock(const int16_t *decoded, uint8_t *encoded) OVERRIDE;
void choosePredictorForBlock(const int16_t *decoded);
};
static inline int clamp(int x, int low, int high)
{
if (x < low) return low;
if (x > high) return high;
return x;
}
static const int16_t adaptationTable[] =
{
230, 230, 230, 230, 307, 409, 512, 614,
768, 614, 512, 409, 307, 230, 230, 230
};
// Compute a linear PCM value from the given differential coded value.
static int16_t decodeSample(ms_adpcm_state &state,
uint8_t code, const int16_t *coefficient)
{
int linearSample = (state.sample1 * coefficient[0] +
state.sample2 * coefficient[1]) >> 8;
linearSample += ((code & 0x08) ? (code - 0x10) : code) * state.delta;
linearSample = clamp(linearSample, MIN_INT16, MAX_INT16);
int delta = (state.delta * adaptationTable[code]) >> 8;
if (delta < 16)
delta = 16;
state.delta = delta;
state.sample2 = state.sample1;
state.sample1 = linearSample;
return static_cast<int16_t>(linearSample);
}
// Compute a differential coded value from the given linear PCM sample.
static uint8_t encodeSample(ms_adpcm_state &state, int16_t sample,
const int16_t *coefficient)
{
int predictor = (state.sample1 * coefficient[0] +
state.sample2 * coefficient[1]) >> 8;
int code = sample - predictor;
int bias = state.delta / 2;
if (code < 0)
bias = -bias;
code = (code + bias) / state.delta;
code = clamp(code, -8, 7) & 0xf;
predictor += ((code & 0x8) ? (code - 0x10) : code) * state.delta;
state.sample2 = state.sample1;
state.sample1 = clamp(predictor, MIN_INT16, MAX_INT16);
state.delta = (adaptationTable[code] * state.delta) >> 8;
if (state.delta < 16)
state.delta = 16;
return code;
}
// Decode one block of MS ADPCM data.
int MSADPCM::decodeBlock(const uint8_t *encoded, int16_t *decoded)
{
ms_adpcm_state decoderState[2];
ms_adpcm_state *state[2];
int channelCount = m_track->f.channelCount;
// Calculate the number of bytes needed for decoded data.
int outputLength = m_framesPerPacket * sizeof (int16_t) * channelCount;
state[0] = &decoderState[0];
if (channelCount == 2)
state[1] = &decoderState[1];
else
state[1] = &decoderState[0];
// Initialize block predictor.
for (int i=0; i<channelCount; i++)
{
state[i]->predictorIndex = *encoded++;
assert(state[i]->predictorIndex < m_numCoefficients);
}
// Initialize delta.
for (int i=0; i<channelCount; i++)
{
state[i]->delta = (encoded[1]<<8) | encoded[0];
encoded += sizeof (uint16_t);
}
// Initialize first two samples.
for (int i=0; i<channelCount; i++)
{
state[i]->sample1 = (encoded[1]<<8) | encoded[0];
encoded += sizeof (uint16_t);
}
for (int i=0; i<channelCount; i++)
{
state[i]->sample2 = (encoded[1]<<8) | encoded[0];
encoded += sizeof (uint16_t);
}
const int16_t *coefficient[2] =
{
m_coefficients[state[0]->predictorIndex],
m_coefficients[state[1]->predictorIndex]
};
for (int i=0; i<channelCount; i++)
*decoded++ = state[i]->sample2;
for (int i=0; i<channelCount; i++)
*decoded++ = state[i]->sample1;
/*
The first two samples have already been 'decoded' in
the block header.
*/
int samplesRemaining = (m_framesPerPacket - 2) * m_track->f.channelCount;
while (samplesRemaining > 0)
{
uint8_t code;
int16_t newSample;
code = *encoded >> 4;
newSample = decodeSample(*state[0], code, coefficient[0]);
*decoded++ = newSample;
code = *encoded & 0x0f;
newSample = decodeSample(*state[1], code, coefficient[1]);
*decoded++ = newSample;
encoded++;
samplesRemaining -= 2;
}
return outputLength;
}
int MSADPCM::encodeBlock(const int16_t *decoded, uint8_t *encoded)
{
choosePredictorForBlock(decoded);
int channelCount = m_track->f.channelCount;
// Encode predictor.
for (int c=0; c<channelCount; c++)
*encoded++ = m_state[c].predictorIndex;
// Encode delta.
for (int c=0; c<channelCount; c++)
{
*encoded++ = m_state[c].delta & 0xff;
*encoded++ = m_state[c].delta >> 8;
}
// Enccode first two samples.
for (int c=0; c<channelCount; c++)
m_state[c].sample2 = *decoded++;
for (int c=0; c<channelCount; c++)
m_state[c].sample1 = *decoded++;
for (int c=0; c<channelCount; c++)
{
*encoded++ = m_state[c].sample1 & 0xff;
*encoded++ = m_state[c].sample1 >> 8;
}
for (int c=0; c<channelCount; c++)
{
*encoded++ = m_state[c].sample2 & 0xff;
*encoded++ = m_state[c].sample2 >> 8;
}
ms_adpcm_state *state[2] = { &m_state[0], &m_state[channelCount - 1] };
const int16_t *coefficient[2] =
{
m_coefficients[state[0]->predictorIndex],
m_coefficients[state[1]->predictorIndex]
};
int samplesRemaining = (m_framesPerPacket - 2) * m_track->f.channelCount;
while (samplesRemaining > 0)
{
uint8_t code1 = encodeSample(*state[0], *decoded++, coefficient[0]);
uint8_t code2 = encodeSample(*state[1], *decoded++, coefficient[1]);
*encoded++ = (code1 << 4) | code2;
samplesRemaining -= 2;
}
return m_bytesPerPacket;
}
void MSADPCM::choosePredictorForBlock(const int16_t *decoded)
{
const int kPredictorSampleLength = 3;
int channelCount = m_track->f.channelCount;
for (int c=0; c<channelCount; c++)
{
int bestPredictorIndex = 0;
int bestPredictorError = std::numeric_limits<int>::max();
for (int k=0; k<m_numCoefficients; k++)
{
int a0 = m_coefficients[k][0];
int a1 = m_coefficients[k][1];
int currentPredictorError = 0;
for (int i=2; i<2+kPredictorSampleLength; i++)
{
int error = std::abs(decoded[i*channelCount + c] -
((a0 * decoded[(i-1)*channelCount + c] +
a1 * decoded[(i-2)*channelCount + c]) >> 8));
currentPredictorError += error;
}
currentPredictorError /= 4 * kPredictorSampleLength;
if (currentPredictorError < bestPredictorError)
{
bestPredictorError = currentPredictorError;
bestPredictorIndex = k;
}
if (!currentPredictorError)
break;
}
if (bestPredictorError < 16)
bestPredictorError = 16;
m_state[c].predictorIndex = bestPredictorIndex;
m_state[c].delta = bestPredictorError;
}
}
void MSADPCM::describe()
{
m_outChunk->f.byteOrder = _AF_BYTEORDER_NATIVE;
m_outChunk->f.compressionType = AF_COMPRESSION_NONE;
m_outChunk->f.compressionParams = AU_NULL_PVLIST;
}
MSADPCM::MSADPCM(Mode mode, Track *track, File *fh, bool canSeek) :
BlockCodec(mode, track, fh, canSeek),
m_numCoefficients(0),
m_state(NULL)
{
m_state = new ms_adpcm_state[m_track->f.channelCount];
}
MSADPCM::~MSADPCM()
{
delete [] m_state;
}
bool MSADPCM::initializeCoefficients()
{
AUpvlist pv = m_track->f.compressionParams;
long l;
if (_af_pv_getlong(pv, _AF_MS_ADPCM_NUM_COEFFICIENTS, &l))
{
m_numCoefficients = l;
}
else
{
_af_error(AF_BAD_CODEC_CONFIG, "number of coefficients not set");
return false;
}
void *v;
if (_af_pv_getptr(pv, _AF_MS_ADPCM_COEFFICIENTS, &v))
{
memcpy(m_coefficients, v, m_numCoefficients * 2 * sizeof (int16_t));
}
else
{
_af_error(AF_BAD_CODEC_CONFIG, "coefficient array not set");
return false;
}
return true;
}
MSADPCM *MSADPCM::createDecompress(Track *track, File *fh,
bool canSeek, bool headerless, AFframecount *chunkFrames)
{
assert(fh->tell() == track->fpos_first_frame);
MSADPCM *msadpcm = new MSADPCM(Decompress, track, fh, canSeek);
if (!msadpcm->initializeCoefficients())
{
delete msadpcm;
return NULL;
}
*chunkFrames = msadpcm->m_framesPerPacket;
return msadpcm;
}
MSADPCM *MSADPCM::createCompress(Track *track, File *fh,
bool canSeek, bool headerless, AFframecount *chunkFrames)
{
assert(fh->tell() == track->fpos_first_frame);
MSADPCM *msadpcm = new MSADPCM(Compress, track, fh, canSeek);
if (!msadpcm->initializeCoefficients())
{
delete msadpcm;
return NULL;
}
*chunkFrames = msadpcm->m_framesPerPacket;
return msadpcm;
}
bool _af_ms_adpcm_format_ok (AudioFormat *f)
{
if (f->channelCount != 1 && f->channelCount != 2)
{
_af_error(AF_BAD_COMPRESSION,
"MS ADPCM compression requires 1 or 2 channels");
return false;
}
if (f->sampleFormat != AF_SAMPFMT_TWOSCOMP || f->sampleWidth != 16)
{
_af_error(AF_BAD_COMPRESSION,
"MS ADPCM compression requires 16-bit signed integer format");
return false;
}
if (f->byteOrder != _AF_BYTEORDER_NATIVE)
{
_af_error(AF_BAD_COMPRESSION,
"MS ADPCM compression requires native byte order");
return false;
}
return true;
}
FileModule *_af_ms_adpcm_init_decompress (Track *track, File *fh,
bool canSeek, bool headerless, AFframecount *chunkFrames)
{
return MSADPCM::createDecompress(track, fh, canSeek, headerless, chunkFrames);
}
FileModule *_af_ms_adpcm_init_compress (Track *track, File *fh,
bool canSeek, bool headerless, AFframecount *chunkFrames)
{
return MSADPCM::createCompress(track, fh, canSeek, headerless, chunkFrames);
}