wma.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/>.
 *
 */

// Based on xoreos' WMA code which is in turn
// Largely based on the WMA implementation found in FFmpeg.

#ifndef AUDIO_DECODERS_WMA_H
#define AUDIO_DECODERS_WMA_H

#include "common/array.h"
#include "common/bitstream.h"

#include "audio/decoders/codec.h"

namespace Common {
template <class BITSTREAM>
class Huffman;
}

namespace Math {
class MDCT;
}

namespace Audio {

struct WMACoefHuffmanParam;

class WMACodec : public Codec {
public:
    WMACodec(int version, uint32 sampleRate, uint8 channels,
             uint32 bitRate, uint32 blockAlign, Common::SeekableReadStream *extraData = 0);
    ~WMACodec();

    AudioStream *decodeFrame(Common::SeekableReadStream &data);

private:
    static const int kChannelsMax = 2; 

    static const int kBlockBitsMin =  7; 
    static const int kBlockBitsMax = 11; 

    static const int kBlockSizeMax = (1 << kBlockBitsMax);

    static const int kBlockNBSizes = (kBlockBitsMax - kBlockBitsMin + 1);

    static const int kSuperframeSizeMax = 16384;

    static const int kHighBandSizeMax = 16;

    static const int kNoiseTabSize = 8192;

    static const int kLSPPowBits = 7;

    int _version; 

    uint32 _sampleRate; 
    uint8  _channels;   
    uint32 _bitRate;    
    uint32 _blockAlign; 
    byte   _audioFlags; 

    bool _useExpHuffman;       
    bool _useBitReservoir;     
    bool _useVariableBlockLen; 
    bool _useNoiseCoding;      

    bool _resetBlockLengths; 

    int _curFrame;       
    int _frameLen;       
    int _frameLenBits;   
    int _blockSizeCount; 
    int _framePos;       

    int _curBlock;         
    int _blockLen;         
    int _blockLenBits;     
    int _nextBlockLenBits; 
    int _prevBlockLenBits; 

    int _byteOffsetBits;

    // Coefficients
    int    _coefsStart;                       
    int    _coefsEnd[kBlockNBSizes];          
    int    _exponentSizes[kBlockNBSizes];
    uint16 _exponentBands[kBlockNBSizes][25];
    int    _highBandStart[kBlockNBSizes];     
    int    _exponentHighSizes[kBlockNBSizes];
    int    _exponentHighBands[kBlockNBSizes][kHighBandSizeMax];

    typedef Common::Huffman<Common::BitStream8MSB> HuffmanDecoder;
    HuffmanDecoder *_coefHuffman[2];                
    const WMACoefHuffmanParam *_coefHuffmanParam[2]; 

    uint16 *_coefHuffmanRunTable[2];   
    float  *_coefHuffmanLevelTable[2]; 
    uint16 *_coefHuffmanIntTable[2];   

    // Noise
    float _noiseMult;                 
    float _noiseTable[kNoiseTabSize]; 
    int   _noiseIndex;

    HuffmanDecoder *_hgainHuffman; 

    // Exponents
    int   _exponentsBSize[kChannelsMax];
    float _exponents[kChannelsMax][kBlockSizeMax];
    float _maxExponent[kChannelsMax];

    HuffmanDecoder *_expHuffman; 

    // Coded values in high bands
    bool _highBandCoded [kChannelsMax][kHighBandSizeMax];
    int  _highBandValues[kChannelsMax][kHighBandSizeMax];

    // Coefficients
    float _coefs1[kChannelsMax][kBlockSizeMax];
    float _coefs [kChannelsMax][kBlockSizeMax];

    // Line spectral pairs
    float _lspCosTable[kBlockSizeMax];
    float _lspPowETable[256];
    float _lspPowMTable1[(1 << kLSPPowBits)];
    float _lspPowMTable2[(1 << kLSPPowBits)];

    // MDCT
    Common::Array<Math::MDCT *> _mdct;       
    Common::Array<const float *>  _mdctWindow; 

    byte _lastSuperframe[kSuperframeSizeMax + 4];
    int  _lastSuperframeLen; 
    int  _lastBitoffset;     

    // Output
    float _output[kBlockSizeMax * 2];
    float _frameOut[kChannelsMax][kBlockSizeMax * 2];


    // Init helpers

    void init(Common::SeekableReadStream *extraData);

    uint16 getFlags(Common::SeekableReadStream *extraData);
    void evalFlags(uint16 flags, Common::SeekableReadStream *extraData);
    int getFrameBitLength();
    int getBlockSizeCount(uint16 flags);
    uint32 getNormalizedSampleRate();
    bool useNoiseCoding(float &highFreq, float &bps);
    void evalMDCTScales(float highFreq);
    void initNoise();
    void initCoefHuffman(float bps);
    void initMDCT();
    void initExponents();

    HuffmanDecoder *initCoefHuffman(uint16 *&runTable, float *&levelTable,
                                     uint16 *&intTable, const WMACoefHuffmanParam &params);
    void initLSPToCurve();

    // Decoding

    Common::SeekableReadStream *decodeSuperFrame(Common::SeekableReadStream &data);
    bool decodeFrame(Common::BitStream8MSB &bits, int16 *outputData);
    int decodeBlock(Common::BitStream8MSB &bits);

    // Decoding helpers

    bool evalBlockLength(Common::BitStream8MSB &bits);
    bool decodeChannels(Common::BitStream8MSB &bits, int bSize, bool msStereo, bool *hasChannel);
    bool calculateIMDCT(int bSize, bool msStereo, bool *hasChannel);

    void calculateCoefCount(int *coefCount, int bSize) const;
    bool decodeNoise(Common::BitStream8MSB &bits, int bSize, bool *hasChannel, int *coefCount);
    bool decodeExponents(Common::BitStream8MSB &bits, int bSize, bool *hasChannel);
    bool decodeSpectralCoef(Common::BitStream8MSB &bits, bool msStereo, bool *hasChannel,
                            int *coefCount, int coefBitCount);
    float getNormalizedMDCTLength() const;
    void calculateMDCTCoefficients(int bSize, bool *hasChannel,
                                   int *coefCount, int totalGain, float mdctNorm);

    bool decodeExpHuffman(Common::BitStream8MSB &bits, int ch);
    bool decodeExpLSP(Common::BitStream8MSB &bits, int ch);
    bool decodeRunLevel(Common::BitStream8MSB &bits, const HuffmanDecoder &huffman,
        const float *levelTable, const uint16 *runTable, int version, float *ptr,
        int offset, int numCoefs, int blockLen, int frameLenBits, int coefNbBits);

    void lspToCurve(float *out, float *val_max_ptr, int n, float *lsp);

    void window(float *out) const;

    float pow_m1_4(float x) const;

    static int readTotalGain(Common::BitStream8MSB &bits);
    static int totalGainToBits(int totalGain);
    static uint32 getLargeVal(Common::BitStream8MSB &bits);
};

} // End of namespace Audio

#endif // AUDIO_DECODERS_WMA_H