defhook.h

linux嵌入式开发程序

/*===========================================================================
	2D Graphics Library
	ALL RIGHTS RESERVED, COPYRIGHT (C) FUJITSU LIMITED 1993-2002
	LICENSED MATERIAL - PROGRAM PROPERTY OF FUJITSU LIMITED
 ===========================================================================*/

#include "deftypes.h"

/*------------------------------------------------------------------------
            The header file for standard implement modules
 *-----------------------------------------------------------------------*/

/*
 *  Labels to define operation according to exection environment
 *
 *      CSRC                Flag for use C source
 *      AccLen              Data length for access unit (Numbers of bytes:1,2,4)
 */

/*------------------------------------------------------------------------
   VRAM Accessing Word
        DShift      Multiply shift count of accessing word.
        DBits       Bits length of accessing word.
        DMask       Mask pattern of bit offset in accessing word.
        ByteMask    Mask pattern of byte offset in accessing word.
        AdjSft      Left-adjust sfift count.
 *------------------------------------------------------------------------*/

#ifndef AccLen
#define AccLen              4
#endif


#if AccLen==4
typedef unsigned long       Acc ;
typedef unsigned long       AWORD ;
typedef long                ALONG ;
#define DShift              5
#endif

#if AccLen==2
typedef unsigned short      Acc ;
typedef unsigned long       AWORD ;
typedef long                ALONG ;
#define DShift              4
#endif

#if AccLen==1
typedef unsigned char       Acc ;
typedef unsigned long       AWORD ;
typedef long                ALONG ;
#define DShift              3
#endif


#define DBits       (sizeof(Acc)*8)
#define DMask       (DBits-1)
#define ByteMask    (AccLen-1)
#define AWBits      (sizeof(AWORD)*8)
#define AdjSft      (AWBits-DBits)


#if _FR20
#if AccLen==4
#define _GL_masktbl         _GL_masktbl32
#endif
#if AccLen==2
#define _GL_masktbl         _GL_masktbl16
#endif
#if AccLen==1
#define _GL_masktbl         _GL_masktbl8
#endif
#endif /* _FR20 */

/*------------------------------------------------------------------------
     Tile pattern
 *------------------------------------------------------------------------*/

#define TileLen     32          /* Number of pixels                     */
#define TileSft     5           /* Shift counts to multiply tile length */

/*------------------------------------------------------------------------
     Mask pattern
 *------------------------------------------------------------------------*/

#define MaskLen     32
#define MaskSft     5
#define MaskBpl     (1<<(MaskSft-3))
#define MaskBpp     (MaskBpl<<MaskSft)

/*------------------------------------------------------------------------
     Access to VRAM
 *------------------------------------------------------------------------*/


#define _xb(a,o)   *((BYTE  *)(  (BYTE *)(a)+(o) ))
#define _xh(a,o)   *((WORD  *)(  (BYTE *)(a)+(o) ))
#define _xw(a,o)   *((DWORD *)(  (BYTE *)(a)+(o) ))

#define _MR_UB4(a)  ((DWORD)(_xb(a,0)<<24)|(DWORD)(_xb(a,1)<<16)|(DWORD)(_xb(a,2)<<8)|(DWORD)_xb(a,3))
#define _MR_UB2(a)  ((DWORD)(_xb(a,0)<<8)|(DWORD)_xb(a,1))
#define _MR_UB1(a)  (DWORD)_xb(a,0)
#define _MR_UH2(a)  ((DWORD)(_xh(a,0)<<16)|(DWORD)_xh(a,1))
#define _MR_UH1(a)  (DWORD)_xh(a,0)
#define _MR_UW1(a)  (DWORD)_xw(a,0)

#define _MW_B4(a,d) (_xb(a,0)=(BYTE)((d)>>24),_xb(a,1)=(BYTE)((d)>>16),_xb(a,2)=(BYTE)((d)>>8),_xb(a,3)=(BYTE)(d))
#define _MW_B2(a,d) (_xb(a,0)=(BYTE)((d)>>8), _xb(a,1)=(BYTE)(d))
#define _MW_B1(a,d) (_xb(a,0)=(BYTE)(d))
#define _MW_H2(a,d) (_xh(a,0)=(WORD)((d)>>16),_xh(a,1)=(WORD)(d))
#define _MW_H1(a,d) (_xh(a,0)=(WORD)(d))
#define _MW_W1(a,d) (_xw(a,0)=d)

#if _ix86

#define MR_UW   _MR_UB4
#define MR_UH   _MR_UB2
#define MR_UB   _MR_UB1
#define MW_W    _MW_B4
#define MW_H    _MW_B2
#define MW_B    _MW_B1

#else

#if AccLen==4

#define MR_UW   _MR_UW1
#define MR_UH   _MR_UH1
#define MR_UB   _MR_UB1
#define MW_W    _MW_W1
#define MW_H    _MW_H1
#define MW_B    _MW_B1

#endif

#if AccLen==2

#define MR_UW   _MR_UH2
#define MR_UH   _MR_UH1
#define MR_UB   _MR_UB1
#define MW_W    _MW_H2
#define MW_H    _MW_H1
#define MW_B    _MW_B1
#endif

#if AccLen==1

#define MR_UW   _MR_UB4
#define MR_UH   _MR_UB2
#define MR_UB   _MR_UB1
#define MW_W    _MW_B4
#define MW_H    _MW_B2
#define MW_B    _MW_B1

#endif

#endif  /* _ix86 */

#if AccLen==4
#define MR      MR_UW
#define MW      MW_W
#endif

#if AccLen==2
#define MR      MR_UH
#define MW      MW_H
#endif

#if AccLen==1
#define MR      MR_UB
#define MW      MW_B
#endif

#ifdef _GL_VRAM3210

#define VR_UW(a) ((DWORD)(_xb(a,3)<<24)|(DWORD)(_xb(a,2)<<16)|(DWORD)(_xb(a,1)<<8)|(DWORD)_xb(a,0))
#define VR_UH(a) ((DWORD)(_xb((DWORD)(a)^3,0)<<8)|(DWORD)(_xb((DWORD)(a)^3,1)))
#define VR_UB(a) ((DWORD)(_xb((DWORD)(a)^3,0)))

#define VW_W(a,d) (_xb(a,3)=(BYTE)((d)>>24),_xb(a,2)=(BYTE)((d)>>16),_xb(a,1)=(BYTE)((d)>>8),_xb(a,0)=(BYTE)(d))
#define VW_H(a,d) (_xb((DWORD)(a)^3,0)=(BYTE)((d)>>8), _xb((DWORD)(a)^3,1)=(BYTE)(d))
#define VW_B(a,d) (_xb((DWORD)(a)^3,0)=(BYTE)(d))

#define VR      VR_UW
#define VW      VW_W

#else

#define VR      MR
#define VR_UB   MR_UB
#define VR_UH   MR_UH
#define VR_UW   MR_UW
#define VW      MW
#define VW_B    MW_B
#define VW_H    MW_H
#define VW_W    MW_W

#endif

/*------------------------------------------------------------------------
**  Optimized process
**      Abs(Value)             Returns absolute value
**      Sign(Value)            Returns 1 or -1 according to sign of value
**------------------------------------------------------------------------*/

#define Abs(i)              (((unsigned long)(i)^((long)(i)>>31))-((long)(i)>>31))
#define Sign(i)             (((i)>>(sizeof(i)*8-1))|1)
#define Min(a,b)            ( (a)<(b) ? (a) : (b) )


#define AdjAccOffs(offs, bitp)                          \
{                                                       \
    bitp += (offs&ByteMask) << 3 ;                      \
    offs=offs-(offs&ByteMask)+((bitp>>3)&~ByteMask) ;   \
    bitp &= DMask ;                                     \
}


#define AdjAccOffs32(offs, bitp)            \
{                                           \
    bitp += (offs&3) << 3 ;                 \
    offs  = offs - (offs&3) + ((bitp>>3)&~3) ;     \
    bitp &= 31 ;                            \
}

/*#define AdjAccAdr(adr, bitp)    AdjAccOffs((DWORD)(adr), bitp)*/

#define AdjAccAdr(adr, bitp)                            \
{                                                       \
    bitp += ((DWORD)adr & ByteMask) << 3 ;              \
    adr   = (BYTE *)adr - ((DWORD)adr&ByteMask)+((bitp>>3)&~ByteMask) ;   \
    bitp &= DMask ;                                     \
}

/*#define AdjAccAdr32(adr, bitp)  AdjAccOffs32((DWORD)(adr), bitp)*/

#define AdjAccAdr32(adr, bitp)              \
{                                           \
    bitp += ((DWORD)(adr)&3) << 3 ;         \
    adr=(void *)((DWORD)(adr)-((DWORD)(adr)&3)+((bitp>>3)&~3)) ;     \
    bitp &= 31 ;                            \
}

#define SelPlane(gp, i)     (*gp->hook.selplane)(gp,(short)(i),(short)(1<<(i)))

/*------------------------------------------------------------------------*
 *  Definition to define operation according to exection environment
 *
 *      _AddAdr(Accumulated Value)           Add pointer
 *      _AddAdrHigh(Accumulated Value)       Add pointer
 *------------------------------------------------------------------------*/

#define _AddAdr(p,o) ((void _Far *)((char _Far *)(p)+(o)))
#define _AddAdrHigh(p,o) ((void _Far *)((char _Far *)(p)+(o)))

#define Mul16(a,b)          ((long)(a)*(b))