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) override;
    void close() override;
 
    Common::Rational getFrameRate();
 
protected:
    void readNextPacket() override;
    bool supportsAudioTrackSwitching() const override { return true; }
    AudioTrack *getAudioTrack(int index) override;
    bool seekIntern(const Audio::Timestamp &time) override;
    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) override;
        bool isSeekable() const override { return true; }
        void skipSamples(const Audio::Timestamp &length);
        int getRate();
 
    protected:
        Audio::AudioStream *getAudioStream() const override;
 
    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