indeo.h

Go to the documentation of this file.

/* 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#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;
    Graphics::PixelFormat _pixelFormat;
    Graphics::Surface _surface;

    static const uint8 _ffIviVerticalScan8x8[64];
    static const uint8 _ffIviHorizontalScan8x8[64];
    static const uint8 _ffIviDirectScan4x4[16];
protected:
    virtual Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }

    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);
    virtual ~IndeoDecoderBase();
};

} // End of namespace Indeo
} // End of namespace Image

#endif