adpcm_intern.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef AUDIO_ADPCM_INTERN_H
#define AUDIO_ADPCM_INTERN_H

#include "audio/audiostream.h"
#include "common/endian.h"
#include "common/ptr.h"
#include "common/array.h"
#include "common/stream.h"
#include "common/textconsole.h"

namespace Audio {

class ADPCMStream : public SeekableAudioStream {
protected:
    Common::DisposablePtr<Common::SeekableReadStream> _stream;
    int32 _startpos;
    const int32 _endpos;
    const int _channels;
    const uint32 _blockAlign;
    uint32 _blockPos[2];
    const int _rate;

    struct ADPCMStatus {
        // OKI/IMA
        struct {
            int32 last;
            int32 stepIndex;
            int16 sample[2];
        } ima_ch[2];
    } _status;

    virtual void reset();

public:
    ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign);

    virtual bool endOfData() const { return (_stream->eos() || _stream->pos() >= _endpos); }
    virtual bool isStereo() const { return _channels == 2; }
    virtual int getRate() const { return _rate; }

    virtual bool rewind();
    virtual bool seek(const Timestamp &where) { return false; }
    virtual Timestamp getLength() const { return Timestamp(); }

    static const int16 _stepAdjustTable[16];
};

class Oki_ADPCMStream : public ADPCMStream {
public:
    Oki_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
        : ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) { _decodedSampleCount = 0; }

    virtual bool endOfData() const { return (_stream->eos() || _stream->pos() >= _endpos) && (_decodedSampleCount == 0); }

    virtual int readBuffer(int16 *buffer, const int numSamples);

protected:
    int16 decodeOKI(byte);

private:
    uint8 _decodedSampleCount;
    int16 _decodedSamples[2];
};

class XA_ADPCMStream : public ADPCMStream {
public:
    XA_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
        : ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) { _decodedSampleCount = 0; }

    virtual bool endOfData() const { return (_stream->eos() || _stream->pos() >= _endpos) && (_decodedSampleCount == 0); }

    virtual int readBuffer(int16 *buffer, const int numSamples);

protected:
    void decodeXA(const byte *src);

private:
    uint8 _decodedSampleCount;
    uint8 _decodedSampleIndex;
    int16 _decodedSamples[28 * 2 * 4];
};

class Ima_ADPCMStream : public ADPCMStream {
protected:
    int16 decodeIMA(byte code, int channel = 0, int shift = 3); // Default to using the left channel/using one channel

public:
    Ima_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
        : ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {}

    static const int16 _imaTable[89];
};

class DVI_ADPCMStream : public Ima_ADPCMStream {
public:
    DVI_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
        : Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) { _decodedSampleCount = 0; }

    virtual bool endOfData() const { return (_stream->eos() || _stream->pos() >= _endpos) && (_decodedSampleCount == 0); }

    virtual int readBuffer(int16 *buffer, const int numSamples);

private:
    uint8 _decodedSampleCount;
    int16 _decodedSamples[2];
};

class Apple_ADPCMStream : public Ima_ADPCMStream {
protected:
    // Apple QuickTime IMA ADPCM
    int32 _streamPos[2];
    int16 _buffer[2][2];
    uint8 _chunkPos[2];

    void reset() {
        Ima_ADPCMStream::reset();
        _chunkPos[0] = 0;
        _chunkPos[1] = 0;
        _streamPos[0] = 0;
        _streamPos[1] = _blockAlign;
    }

public:
    Apple_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
        : Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {
        _chunkPos[0] = 0;
        _chunkPos[1] = 0;
        _streamPos[0] = 0;
        _streamPos[1] = _blockAlign;
    }

    virtual int readBuffer(int16 *buffer, const int numSamples);
};

class MSIma_ADPCMStream : public Ima_ADPCMStream {
public:
    MSIma_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
        : Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {

        if (blockAlign == 0)
            error("MSIma_ADPCMStream(): blockAlign isn't specified");

        if (blockAlign % (_channels * 4))
            error("MSIma_ADPCMStream(): invalid blockAlign");

        _samplesLeft[0] = 0;
        _samplesLeft[1] = 0;
    }

    virtual int readBuffer(int16 *buffer, const int numSamples);

    void reset() {
        Ima_ADPCMStream::reset();
        _samplesLeft[0] = 0;
        _samplesLeft[1] = 0;
    }

private:
    int16 _buffer[2][8];
    int _samplesLeft[2];
};

class MS_ADPCMStream : public ADPCMStream {
protected:
    struct ADPCMChannelStatus {
        byte predictor;
        int16 delta;
        int16 coeff1;
        int16 coeff2;
        int16 sample1;
        int16 sample2;
    };

    struct {
        // MS ADPCM
        ADPCMChannelStatus ch[2];
    } _status;

    void reset() {
        ADPCMStream::reset();
        memset(&_status, 0, sizeof(_status));
    }

public:
    MS_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
        : ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {
        if (blockAlign == 0)
            error("MS_ADPCMStream(): blockAlign isn't specified for MS ADPCM");
        memset(&_status, 0, sizeof(_status));
        _decodedSampleCount = 0;
        _decodedSampleIndex = 0;
    }

    virtual bool endOfData() const { return (_stream->eos() || _stream->pos() >= _endpos) && (_decodedSampleCount == 0); }

    virtual int readBuffer(int16 *buffer, const int numSamples);

protected:
    int16 decodeMS(ADPCMChannelStatus *c, byte);

private:
    uint8 _decodedSampleCount;
    uint8 _decodedSampleIndex;
    int16 _decodedSamples[4];
};

// Duck DK3 IMA ADPCM Decoder
// Based on FFmpeg's decoder and https://wiki.multimedia.cx/index.php?title=Duck_DK3_IMA_ADPCM

class DK3_ADPCMStream : public Ima_ADPCMStream {
public:
    DK3_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels, uint32 blockAlign)
        : Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, blockAlign) {

        // DK3 only works as a stereo stream
        assert(channels == 2);
    }

    virtual int readBuffer(int16 *buffer, const int numSamples);

private:
    byte _nibble, _lastByte;
    bool _topNibble;
};

class FOURXM_ADPCMStream : public Ima_ADPCMStream {
public:
    FOURXM_ADPCMStream(Common::SeekableReadStream *stream, DisposeAfterUse::Flag disposeAfterUse, uint32 size, int rate, int channels)
        : Ima_ADPCMStream(stream, disposeAfterUse, size, rate, channels, 0) {
        decode();
    }

    int readBuffer(int16 *buffer, const int numSamples) override;
    bool endOfData() const override {
        return !_planes.empty() && _samplePos >= _planes[0].size();
    }

    void reset() override {
        Ima_ADPCMStream::reset();
        _samplePos = 0;
        _planes.clear();
    }

private:
    void decode();

    uint _samplePos = 0;
    Common::Array<Common::Array<int16>> _planes;
};

} // End of namespace Audio

#endif