bink_decoder.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 eos' Bink decoder which is in turn
// based quite heavily on the Bink decoder found in FFmpeg.
// Many thanks to Kostya Shishkov for doing the hard work.

#include "common/scummsys.h"

#ifdef USE_BINK

#ifndef VIDEO_BINK_DECODER_H
#define VIDEO_BINK_DECODER_H

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

#include "video/video_decoder.h"

#include "graphics/surface.h"

namespace Audio {
class AudioStream;
class QueuingAudioStream;
}

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

namespace Math {
class RDFT;
class DCT;
}

namespace Graphics {
struct Surface;
}

namespace Video {

class BinkDecoder : public VideoDecoder {
public:
    BinkDecoder();
    ~BinkDecoder();

    bool loadStream(Common::SeekableReadStream *stream);
    void close();

    Common::Rational getFrameRate();

protected:
    void readNextPacket();
    bool supportsAudioTrackSwitching() const { return true; }
    AudioTrack *getAudioTrack(int index);
    bool seekIntern(const Audio::Timestamp &time);
    uint32 findKeyFrame(uint32 frame) const;

private:
    static const int kAudioChannelsMax  = 2;
    static const int kAudioBlockSizeMax = (kAudioChannelsMax << 11);

    enum AudioCodec {
        kAudioCodecDCT,
        kAudioCodecRDFT
    };

    struct AudioInfo {
        uint16 flags;

        uint32 sampleRate;
        uint8  channels;

        uint32 outSampleRate;
        uint8  outChannels;

        AudioCodec codec;

        uint32 sampleCount;

        Common::BitStream32LELSB *bits;

        bool first;

        uint32 frameLen;
        uint32 overlapLen;

        uint32 blockSize;

        uint32  bandCount;
        uint32 *bands;

        float root;

        float coeffs[16 * kAudioBlockSizeMax];
        int16 prevCoeffs[kAudioBlockSizeMax];

        float *coeffsPtr[kAudioChannelsMax];

        Math::RDFT *rdft;
        Math::DCT  *dct;

        AudioInfo();
        ~AudioInfo();
    };

    struct VideoFrame {
        bool keyFrame;

        uint32 offset;
        uint32 size;

        Common::BitStream32LELSB *bits;

        VideoFrame();
        ~VideoFrame();
    };

    class BinkVideoTrack : public FixedRateVideoTrack {
    public:
        BinkVideoTrack(uint32 width, uint32 height, uint32 frameCount, const Common::Rational &frameRate, bool swapPlanes, bool hasAlpha, uint32 id);
        ~BinkVideoTrack();

        uint16 getWidth() const override { return _width; }
        uint16 getHeight() const  override{ return _height; }
        Graphics::PixelFormat getPixelFormat() const override { return _pixelFormat; }
        bool setOutputPixelFormat(const Graphics::PixelFormat &format) override {
            if (format.bytesPerPixel != 2 && format.bytesPerPixel != 4)
                return false;
            _pixelFormat = format;
            return true;
        }

        int getCurFrame() const override { return _curFrame; }
        int getFrameCount() const override { return _frameCount; }
        const Graphics::Surface *decodeNextFrame() override { return _surface; }
        bool isSeekable() const  override{ return true; }
        bool seek(const Audio::Timestamp &time) override { return true; }
        bool rewind() override;
        void setCurFrame(uint32 frame) { _curFrame = frame; }

        void decodePacket(VideoFrame &frame);

        Common::Rational getFrameRate() const override { return _frameRate; }

    private:
        struct DecodeContext {
            VideoFrame *video;

            uint32 planeIdx;

            uint32 blockX;
            uint32 blockY;

            byte *dest;
            byte *prev;

            byte *destStart, *destEnd;
            byte *prevStart, *prevEnd;

            uint32 pitch;

            int coordMap[64];
            int coordScaledMap1[64];
            int coordScaledMap2[64];
            int coordScaledMap3[64];
            int coordScaledMap4[64];
        };

        enum Source {
            kSourceBlockTypes    = 0, 
            kSourceSubBlockTypes    , 
            kSourceColors           , 
            kSourcePattern          , 
            kSourceXOff             , 
            kSourceYOff             , 
            kSourceIntraDC          , 
            kSourceInterDC          , 
            kSourceRun              , 

            kSourceMAX
        };

        enum BlockType {
            kBlockSkip    = 0,  
            kBlockScaled     ,  
            kBlockMotion     ,  
            kBlockRun        ,  
            kBlockResidue    ,  
            kBlockIntra      ,  
            kBlockFill       ,  
            kBlockInter      ,  
            kBlockPattern    ,  
            kBlockRaw           
        };

        struct Huffman {
            int  index;       
            byte symbols[16]; 
        };

        struct Bundle {
            int countLengths[2]; 
            int countLength;     

            Huffman huffman; 

            byte *data;    
            byte *dataEnd; 

            byte *curDec; 
            byte *curPtr; 
        };

        int _curFrame;
        int _frameCount;

        Graphics::Surface *_surface;
        Graphics::PixelFormat _pixelFormat;
        uint16 _width;
        uint16 _height;
        int _surfaceWidth; 
        int _surfaceHeight; 

        uint32 _id; 

        bool _hasAlpha;   
        bool _swapPlanes; 

        Common::Rational _frameRate;

        Bundle _bundles[kSourceMAX]; 

        Common::Huffman<Common::BitStream32LELSB> *_huffman[16]; 

        Huffman _colHighHuffman[16];
        int _colLastVal;

        uint32 _yBlockWidth;   
        uint32 _yBlockHeight;  
        uint32 _uvBlockWidth;  
        uint32 _uvBlockHeight; 

        byte *_curPlanes[4]; 
        byte *_oldPlanes[4]; 

        void initBundles();
        void deinitBundles();

        void initHuffman();

        void decodePlane(VideoFrame &video, int planeIdx, bool isChroma);

        void readBundle(VideoFrame &video, Source source);

        void readHuffman(VideoFrame &video, Huffman &huffman);
        void mergeHuffmanSymbols(VideoFrame &video, byte *dst, const byte *src, int size);

        byte getHuffmanSymbol(VideoFrame &video, Huffman &huffman);

        int32 getBundleValue(Source source);
        uint32 readBundleCount(VideoFrame &video, Bundle &bundle);

        // Handle the block types
        void blockSkip         (DecodeContext &ctx);
        void blockScaledSkip   (DecodeContext &ctx);
        void blockScaledRun    (DecodeContext &ctx);
        void blockScaledIntra  (DecodeContext &ctx);
        void blockScaledFill   (DecodeContext &ctx);
        void blockScaledPattern(DecodeContext &ctx);
        void blockScaledRaw    (DecodeContext &ctx);
        void blockScaled       (DecodeContext &ctx);
        void blockMotion       (DecodeContext &ctx);
        void blockRun          (DecodeContext &ctx);
        void blockResidue      (DecodeContext &ctx);
        void blockIntra        (DecodeContext &ctx);
        void blockFill         (DecodeContext &ctx);
        void blockInter        (DecodeContext &ctx);
        void blockPattern      (DecodeContext &ctx);
        void blockRaw          (DecodeContext &ctx);

        // Read the bundles
        void readRuns        (VideoFrame &video, Bundle &bundle);
        void readMotionValues(VideoFrame &video, Bundle &bundle);
        void readBlockTypes  (VideoFrame &video, Bundle &bundle);
        void readPatterns    (VideoFrame &video, Bundle &bundle);
        void readColors      (VideoFrame &video, Bundle &bundle);
        template<int startBits, bool hasSign>
        void readDCS         (VideoFrame &video, Bundle &bundle);
        void readDCTCoeffs   (VideoFrame &video, int32 *block, bool isIntra);
        void readResidue     (VideoFrame &video, int16 *block, int masksCount);

        // Bink video IDCT
        void IDCT(int32 *block);
        void IDCTPut(DecodeContext &ctx, int32 *block);
        void IDCTAdd(DecodeContext &ctx, int32 *block);
    };

    class BinkAudioTrack : public AudioTrack {
    public:
        BinkAudioTrack(AudioInfo &audio, Audio::Mixer::SoundType soundType);
        ~BinkAudioTrack();

        void decodePacket();

        bool seek(const Audio::Timestamp &time);
        bool isSeekable() const { return true; }
        void skipSamples(const Audio::Timestamp &length);
        int getRate();

    protected:
        Audio::AudioStream *getAudioStream() const;

    private:
        AudioInfo *_audioInfo;
        Audio::QueuingAudioStream *_audioStream;

        float getFloat();

        void audioBlock(int16 *out);
        void audioBlockDCT();
        void audioBlockRDFT();

        void readAudioCoeffs(float *coeffs);

        static void floatToInt16Interleave(int16 *dst, const float **src, uint32 length, uint8 channels);
    };

    Common::SeekableReadStream *_bink;

    Common::Array<AudioInfo> _audioTracks; 
    Common::Array<VideoFrame> _frames;      

    void initAudioTrack(AudioInfo &audio);
};

} // End of namespace Video

#endif // VIDEO_BINK_DECODER_H

#endif // USE_BINK