indeo.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/>.
 *
 */
 
#include "common/scummsys.h"
#include "graphics/surface.h"
#include "image/codecs/codec.h"
 
/* Common structures, macros, and base class shared by both Indeo4 and
 * Indeo5 decoders, derived from ffmpeg. We don't currently support Indeo5
 * decoding, but just in case we eventually need it, this is kept as a separate
 * file like it is in ffmpeg.
 *
 * Original copyright note: * Intel Indeo 4 (IV41, IV42, etc.) video decoder for ffmpeg
 * written, produced, and directed by Alan Smithee
 */
 
#ifndef IMAGE_CODECS_INDEO_INDEO_H
#define IMAGE_CODECS_INDEO_INDEO_H
 
#include "image/codecs/indeo/get_bits.h"
#include "image/codecs/indeo/vlc.h"
 
namespace Image {
namespace Indeo {
 
enum {
    IVI4_FRAMETYPE_INTRA       = 0,
    IVI4_FRAMETYPE_INTRA1      = 1,  
    IVI4_FRAMETYPE_INTER       = 2,  
    IVI4_FRAMETYPE_BIDIR       = 3,  
    IVI4_FRAMETYPE_INTER_NOREF = 4,  
    IVI4_FRAMETYPE_NULL_FIRST  = 5,  
    IVI4_FRAMETYPE_NULL_LAST   = 6   
};
 
enum {
    IVI_MB_HUFF   = 0,      
    IVI_BLK_HUFF  = 1       
};
 
typedef void (InvTransformPtr)(const int32 *in, int16 *out, uint32 pitch, const uint8 *flags);
typedef void (DCTransformPtr)(const int32 *in, int16 *out, uint32 pitch, int blkSize);
 
typedef void (*IviMCFunc)(int16 *buf, const int16 *refBuf, uint32 pitch, int mcType);
typedef void (*IviMCAvgFunc)(int16 *buf, const int16 *refBuf1, const int16 *refBuf2,
    uint32 pitch, int mcType, int mcType2);
 
#define IVI_VLC_BITS 13
#define IVI5_IS_PROTECTED 0x20
 
#define IVI_TOSIGNED(val) (-(((val) >> 1) ^ -((val) & 1)))
 
#define IVI_MBs_PER_TILE(tileWidth, tileHeight, mbSize) \
    ((((tileWidth) + (mbSize) - 1) / (mbSize)) * (((tileHeight) + (mbSize) - 1) / (mbSize)))
 
struct IVIHuffDesc {
    int32       _numRows;
    uint8       _xBits[16];
 
    int createHuffFromDesc(VLC *vlc, bool flag) const;
 
    bool huffDescCompare(const IVIHuffDesc *desc2) const;
 
    void huffDescCopy(const IVIHuffDesc *src);
};
 
struct IVI45DecContext;
 
struct IVIHuffTab {
public:
    int32   _tabSel;    
    VLC *   _tab;       
 
    IVIHuffDesc _custDesc;  
    VLC         _custTab;   
 
    IVIHuffTab();
 
    int decodeHuffDesc(IVI45DecContext *ctx, int descCoded, int whichTab);
};
 
struct RVMapDesc {
    uint8     _eobSym; 
    uint8     _escSym; 
    uint8     _runtab[256];
    int8      _valtab[256];
};
 
struct IVIMbInfo {
    int16   _xPos;
    int16   _yPos;
    uint32  _bufOffs;   
    uint8   _type;      
    uint8   _cbp;       
    int8    _qDelta;    
    int8    _mvX;       
    int8    _mvY;       
    int8    _bMvX;      
    int8    _bMvY;      
 
    IVIMbInfo();
};
 
struct IVITile {
    int         _xPos;
    int         _yPos;
    int         _width;
    int         _height;
    int         _mbSize;
    bool        _isEmpty;
    int         _dataSize;  
    int         _numMBs;    
    IVIMbInfo * _mbs;       
    IVIMbInfo * _refMbs;    
 
    IVITile();
};
 
struct IVIBandDesc {
    int             _plane;         
    int             _bandNum;       
    int             _width;
    int             _height;
    int             _aHeight;       
    const uint8 *   _dataPtr;       
    int             _dataSize;      
    int16 *         _buf;           
    int16 *         _refBuf;        
    int16 *         _bRefBuf;       
    int16 *         _bufs[4];       
    int             _pitch;         
    bool            _isEmpty;
    int             _mbSize;        
    int             _blkSize;       
    uint8           _isHalfpel;     
    bool            _inheritMv;     
    bool            _inheritQDelta; 
    bool            _qdeltaPresent; 
    int             _quantMat;      
    int             _globQuant;     
    const uint8 *   _scan;          
    int             _scanSize;      
 
    IVIHuffTab      _blkVlc;        
 
    int             _numCorr;       
    uint8           _corr[61 * 2];  
    int             _rvmapSel;      
    RVMapDesc *     _rvMap;         
    int             _numTiles;      
    IVITile *       _tiles;         
    InvTransformPtr *_invTransform;
    int             _transformSize;
    DCTransformPtr *_dcTransform;
    bool            _is2dTrans;
    int32           _checksum;      
    int             _checksumPresent;
    int             _bufSize;       
    const uint16 *  _intraBase;     
    const uint16 *  _interBase;     
    const uint8 *   _intraScale;    
    const uint8 *   _interScale;    
 
    IVIBandDesc();
 
    int initTiles(IVITile *refTile, int p, int b, int tHeight, int tWidth);
};
 
struct IVIPicConfig {
    uint16      _picWidth;
    uint16      _picHeight;
    uint16      _chromaWidth;
    uint16      _chromaHeight;
    uint16      _tileWidth;
    uint16      _tileHeight;
    uint8       _lumaBands;
    uint8       _chromaBands;
 
    IVIPicConfig();
 
    bool ivi_pic_config_cmp(const IVIPicConfig &cfg2);
};
 
struct IVIPlaneDesc {
    uint16          _width;
    uint16          _height;
    uint8           _numBands;  
    IVIBandDesc *   _bands;     
 
    IVIPlaneDesc();
 
    static int initPlanes(IVIPlaneDesc *planes, const IVIPicConfig *cfg, bool isIndeo4);
 
    static int initTiles(IVIPlaneDesc *planes, int tileWidth, int tileHeight);
 
    static void freeBuffers(IVIPlaneDesc *planes);
 
    static int checkImageSize(unsigned int w, unsigned int h, int logOffset);
};
 
struct AVFrame {
    int _width, _height;
 
#define AV_NUM_DATA_POINTERS 3
    uint8 *_data[AV_NUM_DATA_POINTERS];
 
    int _linesize[AV_NUM_DATA_POINTERS];
 
    AVFrame();
 
    ~AVFrame() { freeFrame(); }
 
    int setDimensions(uint16 width, uint16 height);
 
    int getBuffer(int flags);
 
    void freeFrame();
};
 
struct IVI45DecContext {
    friend struct IVIHuffTab;
private:
    VLC_TYPE _tableData[8192 * 16][2];
    VLC _iviMbVlcTabs[8];           
    VLC _iviBlkVlcTabs[8];          
public:
    GetBits *       _gb;
    RVMapDesc       _rvmapTabs[9];  
 
    uint32          _frameNum;
    int             _frameType;
    int             _prevFrameType; 
    uint32          _dataSize;      
    int             _isScalable;
    const uint8 *   _frameData;     
    int             _interScal;     
    uint32          _frameSize;     
    uint32          _picHdrSize;    
    uint8           _frameFlags;
    uint16          _checksum;      
 
    IVIPicConfig    _picConf;
    IVIPlaneDesc    _planes[3];     
 
    int             _bufSwitch;     
    int             _dstBuf;        
    int             _refBuf;        
    int             _ref2Buf;       
    int             _bRefBuf;       
 
    IVIHuffTab      _mbVlc;         
    IVIHuffTab      _blkVlc;        
    IVIHuffTab      _transVlc;      
 
    uint8           _rvmapSel;
    bool            _inImf;
    bool            _inQ;           
    uint8           _picGlobQuant;
    uint8           _unknown1;
 
    uint16          _gopHdrSize;
    uint8           _gopFlags;
    uint32          _lockWord;
 
    bool            _hasBFrames;
    bool            _hasTransp;     
    bool            _usesTiling;
    bool            _usesHaar;
    bool            _usesFullpel;
 
    bool            _gopInvalid;
    int             _bufInvalid[4];
 
    bool            _isIndeo4;
    uint32          _transKeyColor;
 
    AVFrame *       _pFrame;
    bool            _gotPFrame;
 
    IVI45DecContext();
private:
    static const RVMapDesc _ff_ivi_rvmap_tabs[9];
};
 
class IndeoDecoderBase : public Codec {
private:
    int decode_band(IVIBandDesc *band);
 
    void recomposeHaar(const IVIPlaneDesc *plane, uint8 *dst, const int dstPitch);
 
    void recompose53(const IVIPlaneDesc *plane, uint8 *dst, const int dstPitch);
 
    /*
     *  Convert and output the current plane.
     *  This conversion is done by adding back the bias value of 128
     *  (subtracted in the encoder) and clipping the result.
     *
     *  @param[in]   plane      Pointer to the descriptor of the plane being processed
     *  @param[out]  dst        Pointer to the buffer receiving converted pixels
     *  @param[in]   dstPitch   Pitch for moving to the next y line
     */
    void outputPlane(IVIPlaneDesc *plane, uint8 *dst, int dstPitch);
 
    int processEmptyTile(IVIBandDesc *band, IVITile *tile, int32 mvScale);
 
    /*
     *  Decode size of the tile data.
     *  The size is stored as a variable-length field having the following format:
     *  if (tile_data_size < 255) than this field is only one byte long
     *  if (tile_data_size >= 255) than this field four is byte long: 0xFF X1 X2 X3
     *  where X1-X3 is size of the tile data
     *
     *  @param[in,out]  gb  the GetBit context
     *  @returns    Size of the tile data in bytes
     */
    int decodeTileDataSize(GetBits *gb);
 
    /*
     *  Decode block data:
     *  extract huffman-coded transform coefficients from the bitstream,
     *  dequantize them, apply inverse transform and motion compensation
     *  in order to reconstruct the picture.
     *
     *  @param[in,out]  gb      The GetBit context
     *  @param[in]      band    Pointer to the band descriptor
     *  @param[in]      tile    Pointer to the tile descriptor
     *  @returns    Result code: 0 - OK, -1 = error (corrupted blocks data)
     */
    int decodeBlocks(GetBits *gb, IVIBandDesc *band, IVITile *tile);
 
    int iviMc(IVIBandDesc *band, IviMCFunc mc, IviMCAvgFunc mcAvg,
        int offs, int mvX, int mvY, int mvX2, int mvY2, int mcType, int mcType2);
 
    int decodeCodedBlocks(GetBits *gb, IVIBandDesc *band,
        IviMCFunc mc, IviMCAvgFunc mcAvg, int mvX, int mvY,
        int mvX2, int mvY2, int32 *prevDc, int isIntra,
        int mcType, int mcType2, uint32 quant, int offs);
 
    int iviDcTransform(IVIBandDesc *band, int32 *prevDc, int bufOffs,
        int blkSize);
protected:
    IVI45DecContext _ctx;
    uint16 _width;
    uint16 _height;
    uint _bitsPerPixel;
    Graphics::PixelFormat _pixelFormat;
    Graphics::Surface *_surface;
 
    static const uint8 _ffIviVerticalScan8x8[64];
    static const uint8 _ffIviHorizontalScan8x8[64];
    static const uint8 _ffIviDirectScan4x4[16];
protected:
    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;
    }
 
    virtual int decodePictureHeader() = 0;
 
    virtual void switchBuffers() = 0;
 
    virtual bool isNonNullFrame() const = 0;
 
    virtual int decodeBandHeader(IVIBandDesc *band) = 0;
 
    virtual int decodeMbInfo(IVIBandDesc *band, IVITile *tile) = 0;
 
    virtual int decodeTransparency() { return -1; }
 
    int decodeIndeoFrame();
 
    int scaleMV(int mv, int mvScale);
public:
    IndeoDecoderBase(uint16 width, uint16 height, uint bitsPerPixel);
    ~IndeoDecoderBase() override;
};
 
} // End of namespace Indeo
} // End of namespace Image
 
#endif