xmvwmv2.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 WMV2 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 file libavcodec/wmv2dec.c reads as follows:
 *
 * Copyright (c) 2002 The FFmpeg Project
 *
 * This file is part of FFmpeg.
 *
 * 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_CODECS_XMVWMV2_H
#define VIDEO_CODECS_XMVWMV2_H

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

#include "src/video/codecs/codec.h"

namespace Common {
    class BitStream;
    class Huffman;
}

namespace Video {

struct WMV2ACCoefficientTable;
struct WMV2MVTable;

class XMVWMV2Codec : public Codec {
public:
    XMVWMV2Codec(uint32 width, uint32 height, Common::SeekableReadStream &extraData);
    ~XMVWMV2Codec();

    void decodeFrame(Graphics::Surface &surface, Common::SeekableReadStream &dataStream);

private:
    static const uint32 kMacroBlockSize = 16; 
    static const uint32 kBlockSize      =  8; 

    class CBP {
    public:
        CBP(uint32 cbp = 0);

        void clear();

        bool empty() const;
        bool isSet(int block) const;

        void set(int block, bool coded);

        void decode(uint32 cbp);
        void decode(uint32 cbp, const CBP &topLeft, const CBP &top, const CBP &left);

    private:
        uint8 _cbp;
    };

    struct ACDecoder {
        Common::ScopedPtr<Common::Huffman> huffman;
        const WMV2ACCoefficientTable *parameters;
    };

    struct MVDecoder {
        Common::ScopedPtr<Common::Huffman> huffman;
        const WMV2MVTable *parameters;
    };

    struct BlockContext {
        const byte *refPlane;
              byte *curPlane;

        int32 *acQuantTop;
        int32 *acQuantLeft;

        int32 *dcTopLeft;

        ACDecoder       **decoderAC;
        Common::Huffman **huffDC;

        uint32 dcEscapeCode;

        bool hasACCoeffs;

        uint32 planePitch;
        uint32 blockPitch;
    };

    struct DecodeContext {
        Common::BitStream &bits;

        int32 qScale;
        int32 dcStepSize;
        int32 defaultPredictor;

        int32 *acQuantTop[3];
        int32  acQuantLeft[4][kBlockSize];

        int32 dcTopLeft[4];

        ACDecoder       *decoderAC[2];
        Common::Huffman *huffDC   [2];

        CBP *rowCBP;
        CBP *curCBP;

        CBP cbpTopLeft;
        CBP cbpTop;

        bool hasACPerMacroBlock;
        bool hasACPrediction;

        uint32 acRLERunLength;
        uint32 acRLELevelLength;

        BlockContext block[6];


        DecodeContext(Common::BitStream &b);

        void setQScale(int32 qS);

        void startRow();
        void finishRow();

        void startMacroBlock(uint32 cbp);
        void finishMacroBlock();
    };


    // Dimensions

    uint32 _width;  
    uint32 _height; 

    uint32 _lumaWidth;  
    uint32 _lumaHeight; 

    uint32 _chromaWidth;  
    uint32 _chromaHeight; 

    uint32 _mbCountWidth;  
    uint32 _mbCountHeight; 

    // Color planes

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

    // Decoder flags

    bool _hasMixedPelMC;      
    bool _hasLoopFilter;      
    bool _hasVarSizeTrans;    
    bool _hasJFrames;         
    bool _hasHybridMV;        
    bool _hasACPerMacroBlock; 

    uint8 _sliceCount; 

    // CBP

    Common::ScopedArray<CBP>           _cbp;        
    Common::ScopedPtr<Common::Huffman> _huffCBP[4]; 

    // DCT DC coefficients

    Common::ScopedPtr<Common::Huffman> _huffDC[2][2];

    // DCT AC coefficients

    Common::ScopedArray<int32> _predAC[3]; 

    ACDecoder _decoderAC[2][3];

    // Motion vectors

    MVDecoder _decoderMV[2];

    uint32 _currentFrame;


    void init();

    void parseExtraData(Common::SeekableReadStream &extraData);

    void initDecodeContext(DecodeContext &ctx);

    // Frame type decoders

    void decodeIFrame(DecodeContext &ctx);
    void decodeJFrame(DecodeContext &ctx);
    void decodePFrame(DecodeContext &ctx);

    // Block decoders

    void decodeIMacroBlock(DecodeContext &ctx);

    void decodeIBlock(DecodeContext &ctx, BlockContext &block);

    static uint8 getTrit(Common::BitStream &bits);

    // IDCT

    void IDCTPut(byte *dest, int32 *block, uint32 pitch);
    void IDCT(int32 *block);
    void IDCTRow(int32 *b);
    void IDCTCol(int32 *b);
};

} // End of namespace Video

#endif // VIDEO_CODECS_XMVWMV2_H