bink.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos 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.
 *
 * xoreos 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 xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

/* Based on the Bink implementation in FFmpeg (<https://ffmpeg.org/)>,
 * which is released under the terms of version 2 or later of the GNU
 * Lesser General Public License.
 *
 * The original copyright notes in the files
 * - libavformat/bink.c
 * - libavcodec/bink.c
 * - libavcodec/binkdata.h
 * - libavcodec/binkdsp.c
 * - libavcodec/binkdsp.h
 * - libavcodec/binkaudio.c
 * read as follows:
 *
 * Bink demuxer
 * Copyright (c) 2008-2010 Peter Ross (pross@xvid.org)
 * Copyright (c) 2009 Daniel Verkamp (daniel@drv.nu)
 *
 * Bink video decoder
 * Copyright (c) 2009 Konstantin Shishkov
 * Copyright (C) 2011 Peter Ross <pross@xvid.org>
 *
 * Bink video decoder
 * Copyright (C) 2009 Konstantin Shishkov
 *
 * Bink DSP routines
 * Copyright (c) 2009 Konstantin Shishkov
 *
 * Bink Audio decoder
 * Copyright (c) 2007-2011 Peter Ross (pross@xvid.org)
 * Copyright (c) 2009 Daniel Verkamp (daniel@drv.nu)
 *
 * FFmpeg 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.
 *
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef VIDEO_BINK_H
#define VIDEO_BINK_H

#include <vector>

#include "src/common/types.h"
#include "src/common/rational.h"
#include "src/common/scopedptr.h"

#include "src/video/decoder.h"

namespace Common {
    class SeekableReadStream;
    class BitStream;
    class Huffman;

    class RDFT;
    class DCT;
}

namespace Sound {
    class PacketizedAudioStream;
}

namespace Video {

class Bink : public VideoDecoder {
public:
    Bink(Common::SeekableReadStream *bink);
    ~Bink();

protected:
    void decodeNextTrackFrame(VideoTrack &track);
    void checkAudioBuffer(AudioTrack &track, const Common::Timestamp &endTime);

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;

        bool first;

        uint32 frameLen;
        uint32 overlapLen;

        uint32 blockSize;

        uint32  bandCount;
        uint32 *bands;

        float root;

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

        float *coeffsPtr[kAudioChannelsMax];

        Common::RDFT *rdft;
        Common::DCT  *dct;

        AudioInfo();
        ~AudioInfo();
    };

    struct VideoFrame {
        bool keyFrame;

        uint32 offset;
        uint32 size;

        Common::BitStream *bits;

        VideoFrame();
        ~VideoFrame();
    };

    Common::ScopedPtr<Common::SeekableReadStream> _bink;

    std::vector<AudioInfo> _audioTracks; 
    std::vector<VideoFrame> _frames;      

    uint32 _audioTrack; 

    void load();

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

        uint32 getWidth() const { return _width; }
        uint32 getHeight() const { return _height; }
        int getCurFrame() const { return _curFrame; }
        int getFrameCount() const { return _frameCount; }

        void decodePacket(Graphics::Surface &surface, VideoFrame &frame);

    protected:
        Common::Rational getFrameRate() const { 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]; 

            Huffman();
        };

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

            Huffman huffman; 

            Common::ScopedArray<byte> data; 

            byte *dataEnd; 
            byte *curDec;  
            byte *curPtr;  

            Bundle();
        };

        uint32 _width;
        uint32 _height;

        int _curFrame; 
        int _frameCount;

        Common::Rational _frameRate; 

        bool _swapPlanes; 
        bool _hasAlpha;   

        uint32 _id; 

        Bundle _bundles[kSourceMAX]; 

        Common::ScopedPtr<Common::Huffman> _huffman[16]; 

        Huffman _colHighHuffman[16];
        int _colLastVal;

        Common::ScopedArray<byte> _curPlanes[4]; 
        Common::ScopedArray<byte> _oldPlanes[4]; 

        void initBundles();

        void initHuffman();

        void videoPacket(VideoFrame &video);

        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);
        void readDCS         (VideoFrame &video, Bundle &bundle, int startBits, bool hasSign);
        void readDCTCoeffs   (VideoFrame &video, int16 *block, bool isIntra);
        void readResidue     (VideoFrame &video, int16 *block, int masksCount);

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

    class BinkAudioTrack : public AudioTrack {
    public:
        BinkAudioTrack(size_t index, AudioInfo &audio);
        ~BinkAudioTrack();

        bool canBufferData() const;

        void decodeAudio(Common::SeekableReadStream& bink, const std::vector<VideoFrame>& frames, const std::vector<AudioInfo>& audioTracks, const Common::Timestamp& endTime);

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

    private:
        size_t _index;
        AudioInfo &_info;
        Sound::PacketizedAudioStream *_audioStream;
        uint32 _curFrame;
        Common::Timestamp _audioBuffered;

        float getFloat(Common::BitStream &bits);

        void audioBlock(Common::BitStream &bits, int16 *out);
        void audioBlockDCT(Common::BitStream &bits);
        void audioBlockRDFT(Common::BitStream &bits);

        void readAudioCoeffs(Common::BitStream &bits, float *coeffs);

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

    void initAudioTrack(AudioInfo &audio);
};

} // End of namespace Video

#endif // VIDEO_BINK_H