bit-prec.h

视频601芯片的驱动源码,你可以完全掌控该芯片了,对于其它多媒体芯片的设计具有参考价值

/*------------------------------------------------------------------------

$Workfile: BIT-PREC.H $
$Date: 12/10/96 1:15p $
$Revision: 3 $
* Purpose:	
*			Header for Bin Width Calculator.			
* Notes:       
*
$History: BIT-PREC.H $
 * 
 * *****************  Version 3  *****************
 * User: Az           Date: 12/10/96   Time: 1:15p
 * Updated in $/601cman
 * Added FLOAT2HBW & FLOAT2HBWI  macros.
 * 
 * *****************  Version 2  *****************
 * User: Stevel       Date: 3/14/96    Time: 4:21p
 * Updated in $/601cman
 * Remove typedef VARTYPE to avoid conflict with  Windows header.
 * 
 * *****************  Version 1  *****************
 * User: Stevel       Date: 3/06/96    Time: 7:54p
 * Created in $/601cman
 * Initial release

  
    This code and information is provided "as is" without warranty of any
    kind, either expressed or implied, including but not limited to the
    implied warranties of merchantability and/or fitness for a particular
    purpose.
  
    1996 Analog Devices, Inc. 
  
-------------------------------------------------------------------------*/

/*******************************************************/
/********************** Bit precise operations.s ******/
/*****************************************************/


typedef long  ZBWFTYPE;
typedef long  A_COEFF;
typedef long  S_COEFF;
typedef long  WTYPE;
typedef long  ACCTYPE;
typedef long  PIXTYPE;
typedef long  BWTYPE;
typedef long  BWINVTYPE;
typedef long  RTYPE;


/* 
  CHECK_OVERFLOW = 0  -- no checking
  CHECK_OVERFLOW = 1  -- sign extend overflown bits
  CHECK_OVERFLOW = 2  -- saturate (ADV601)
  CHECK_OVERFLOW = 3  -- abort on overflow
  

  Generally, 1 is the best compromise: it's fast and will 
  "notice" overflows "better" than saturation. To simulate
  ADV601 correctly 2 should be used, though.
  If we don't expect any overflows, use 3.

*/

#define CHECK_OVERFLOW 2

#define OVERFLOW_P(X,NB) (((X)^((X)<<1))&(1<<(NB)))

#if CHECK_OVERFLOW==3
#define CHKOVFLW(X,NB) ({long __t=X; if(OVERFLOW_P(__t,NB)) \
			     report_overflow(X,NB); __t;})
#endif


#if CHECK_OVERFLOW==2
#define NEG_OVERFLOW_P(X,NB) (((X)&(3<<(NB-1)))==(2<<(NB-1)))
#define POS_OVERFLOW_P(X,NB) (((X)&(3<<(NB-1)))==1)
#define NEG_SAT(NB) (1<<(NB-1))
#define POS_SAT(NB) ((1<<(NB-1))-1)
#define SATURATE(X,NB) (NEG_OVERFLOW_P(X,NB)?NEG_SAT(NB):\
		       (POS_OVERFLOW_P(X,NB))?POS_SAT(NB):(X))
#define CHKOVFLW(X,NB)    SATURATE(X,NB)
#endif

#if CHECK_OVERFLOW==1
#define CHKOVFLW(X,NB) (((X)<<(32-(NB)))>>(32-(NB)))
#endif

#if CHECK_OVERFLOW==0
#define CHKOVFLW(X,NB) (X)
#endif

/* Precisions and types */

#define PIX_I 8
#define PIX_F 2

#define A_COEFF_I  2
#define A_COEFF_F 14

#define S_COEFF_I  2
#define S_COEFF_F 14

#define ACC_I 13
#define ACC_F 8

#define WTYPE_I 9
#define WTYPE_F 7

#define BW_I 8
#define BW_F 8

#define BWI_I 6
#define BWI_F 10

#define ZBWF_I 2
#define ZBWF_F 14

#define FLOAT2FIX(X,F) (long)((X)*(1<<(F))-(X<0)+0.5)
#define FIX2FLOAT(N,F) ((real)(N)/(1<<(F)))

#define FLOAT2HBW(X)  FLOAT2FIX(X,8)
#define FLOAT2HBWI(X) FLOAT2FIX(X,10)

#define FLOAT2ACOEFF(X) FLOAT2FIX(X,A_COEFF_F)
#define FLOAT2SCOEFF(X) FLOAT2FIX(X,S_COEFF_F)
#define FLOAT2BW(X)	FLOAT2FIX(X,BW_F)
#define FLOAT2BWI(X)	FLOAT2FIX(X,BWI_F)
#define FLOAT2ZBWF(X)	FLOAT2FIX(X,ZBWF_F)
#define FLOAT2WTYPE(X)	FLOAT2FIX(X,WTYPE_F)
#define WTYPE2FLOAT(X)  FIX2FLOAT(X,WTYPE_F)

/* Used during i/o only: */

#define FLOAT2PIX2WTYPE(X)  (FLOAT2FIX(X,PIX_F)<<(WTYPE_F-PIX_F))

#if WTYPE_F >= PIX_F
#define PIX2WTYPE(X) ((X)<<(WTYPE_F-PIX_F))
#endif

#define BW2FLOAT(X) FIX2FLOAT(X,BW_F)

#define INT2WTYPE(X) ((X)<<WTYPE_F)

#if ACC_F > WTYPE_F
#define ACC2WTYPE(X) CHKOVFLW((((X)+(1<<(ACC_F - WTYPE_F-1)))>>\
			       (ACC_F-WTYPE_F)), WTYPE_I+WTYPE_F)
#define ACC2WTYPE2(X) CHKOVFLW((((X)+(1<<(ACC_F - WTYPE_F)))>>\
			       (ACC_F-WTYPE_F+1)), WTYPE_I+WTYPE_F)
#define WTYPE2ACC(X)  ((X)<<(ACC_F-WTYPE_F))
#endif

#ifdef BIT_PRECISE_PRECISE

/* REGMULT(C,A) returns 0 if it is a special case for multiplier */
/* ADV601 has a slight irregularity in the last LSB */
/* If we want to be 100% bit precise, we have to take this into account */

#define REGMULT1(C,A) ((((C)     &4)|((A)&3))^5)
#define REGMULT2(C,A) (((((C)<<1)&4)|((A)&3))^2)
#define REGMULT3(C,A) ((((C)     &4)|((A)&3))^3)
#define REGMULT(C,A) ((REGMULT1(C,A))*(REGMULT2(C,A))*(REGMULT3(C,A)))
#define FIXMULT(C,A) (REGMULT(C,A)?((C)*(A)):(((C)*(A))-1))
#else
#define FIXMULT(C,A) ((C)*(A))
#endif

#if S_COEFF_F + WTYPE_F > ACC_F
#define S_LSHIFT (S_COEFF_F + WTYPE_F - ACC_F)
#define WS_MULT(C,W) \
	CHKOVFLW(((FIXMULT(C,W)+(1<<(S_LSHIFT-1)))>>S_LSHIFT),ACC_I+ACC_F)
#define WS_MULT_ACC(A,C,W) \
        A+=((FIXMULT(C,W)+(1<<(S_LSHIFT-1)))>>S_LSHIFT); \
    	A=CHKOVFLW(A,ACC_I+ACC_F)
#define WS_MULT_SUB(A,C,W) \
        A-=((FIXMULT(C,W)+(1<<(S_LSHIFT-1)))>>S_LSHIFT); \
    	A=CHKOVFLW(A,ACC_I+ACC_F)
#endif


#if A_COEFF_F + WTYPE_F > ACC_F
#define A_LSHIFT (A_COEFF_F + WTYPE_F - ACC_F)
/* multiply with subsequent division by 2 and rounding */
#define WA_MULT2(C,W) \
    CHKOVFLW(((FIXMULT(C,W)+(1<<(A_LSHIFT)))>>(A_LSHIFT+1)),ACC_I+ACC_F)
#define WA_MULT_ACC(A,C,W) \
	A+=((FIXMULT(C,W)+(1<<(A_LSHIFT-1)))>>A_LSHIFT); \
    	     A=CHKOVFLW(A,ACC_I+ACC_F)
#define WA_MULT_SUB(A,C,W) \
	A-=((FIXMULT(C,W)+(1<<(A_LSHIFT-1)))>>A_LSHIFT); \
	A=CHKOVFLW(A,ACC_I+ACC_F)
#endif


/* multiply bin-width by integer and get WTYPE */

#if (WTYPE_F == BW_F) && (WTYPE_I == BW_I)
#define MULT_BW_I(BW,I)   CHKOVFLW(((BW)*(I)),WTYPE_F+WTYPE_I)
#endif

#if (WTYPE_F > BW_F)
#define MULT_BW_I(BW,I)   CHKOVFLW((((BW)*(I))<<(WTYPE_F-BW_F)),\
				    WTYPE_F+WTYPE_I)
#endif

#if (WTYPE_F < BW_F)
#define MULT_BW_I(BW,I)   CHKOVFLW(((((BW)*(I))+(1<<(BW_F-WTYPE_F-1)))>>\
				    (BW_F-WTYPE_F)), WTYPE_F+WTYPE_I)
#endif

/* Multiply inverse binwidth by WTYPE and get an integer */

#define MULT_BWI_W(BWI,W) ((FIXMULT(BWI,W)+(1<<(BWI_F+WTYPE_F-1)))>> \
			      (BWI_F+WTYPE_F))

/* Multiply Bin-Width by Zero Bin-Width Factor  and get bin-width */

#define MULT_ZBWF_BW(ZF,BW) ((((ZF)*(BW))+(1<<(ZBWF_F-1)))>>ZBWF_F)


/* bitstream conversions: trivial for bit-precise implementation: */

#define BW_BS2I(X)   (X)
#define ZBWF_BS2I(X) (X)
#define BW_I2BS(X)   (X)
#define ZBWF_I2BS(X) (X)

#define BS_BIN_WIDTH(X)  (X)
#define BS_ZBWF(X)       (X)

/* Bin-Width to Wtype: trivial for now */

#if BW_F == WTYPE_F
#define BW2W(X) X
#elif BW_F > WTYPE_F
#define BW2W(X) (((X)+(1<<(BW_F-WTYPE_F-1)))>>(BW_F-WTYPE_F))
#else
    			Syntax Error: Unimplemented !
#endif