Generic fixed-point operations. More...

Macros
#define	MULT16_16SU(a, b) ((opus_val32)(opus_val16)(a)*(opus_val32)(opus_uint16)(b))

#define	MULT16_32_Q16(a, b) ADD32(MULT16_16((a),SHR((b),16)), SHR(MULT16_16SU((a),((b)&0x0000ffff)),16))

#define	MULT16_32_P16(a, b) ADD32(MULT16_16((a),SHR((b),16)), PSHR(MULT16_16SU((a),((b)&0x0000ffff)),16))

#define	MULT16_32_Q15(a, b) ADD32(SHL(MULT16_16((a),SHR((b),16)),1), SHR(MULT16_16SU((a),((b)&0x0000ffff)),15))

#define	MULT32_32_Q31(a, b) ADD32(ADD32(SHL(MULT16_16(SHR((a),16),SHR((b),16)),1), SHR(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),15)), SHR(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),15))

#define	QCONST16(x, bits) ((opus_val16)(.5+(x)*(((opus_val32)1)<<(bits))))

#define	QCONST32(x, bits) ((opus_val32)(.5+(x)*(((opus_val32)1)<<(bits))))

#define	NEG16(x) (-(x))

#define	NEG32(x) (-(x))

#define	EXTRACT16(x) ((opus_val16)(x))

#define	EXTEND32(x) ((opus_val32)(x))

#define	SHR16(a, shift) ((a) >> (shift))

#define	SHL16(a, shift) ((opus_int16)((opus_uint16)(a)<<(shift)))

#define	SHR32(a, shift) ((a) >> (shift))

#define	SHL32(a, shift) ((opus_int32)((opus_uint32)(a)<<(shift)))

#define	PSHR32(a, shift) (SHR32((a)+((EXTEND32(1)<<((shift))>>1)),shift))

#define	VSHR32(a, shift) (((shift)>0) ? SHR32(a, shift) : SHL32(a, -(shift)))

#define	SHR(a, shift) ((a) >> (shift))

#define	SHL(a, shift) SHL32(a,shift)

#define	PSHR(a, shift) (SHR((a)+((EXTEND32(1)<<((shift))>>1)),shift))

#define	SATURATE(x, a) (((x)>(a) ? (a) : (x)<-(a) ? -(a) : (x)))

#define	SATURATE16(x) (EXTRACT16((x)>32767 ? 32767 : (x)<-32768 ? -32768 : (x)))

#define	ROUND16(x, a) (EXTRACT16(PSHR32((x),(a))))

#define	HALF16(x) (SHR16(x,1))

#define	HALF32(x) (SHR32(x,1))

#define	ADD16(a, b) ((opus_val16)((opus_val16)(a)+(opus_val16)(b)))

#define	SUB16(a, b) ((opus_val16)(a)-(opus_val16)(b))

#define	ADD32(a, b) ((opus_val32)(a)+(opus_val32)(b))

#define	SUB32(a, b) ((opus_val32)(a)-(opus_val32)(b))

#define	MULT16_16_16(a, b) ((((opus_val16)(a))*((opus_val16)(b))))

#define	MULT16_16(a, b) (((opus_val32)(opus_val16)(a))*((opus_val32)(opus_val16)(b)))

#define	MAC16_16(c, a, b) (ADD32((c),MULT16_16((a),(b))))

#define	MAC16_32_Q15(c, a, b) ADD32((c),ADD32(MULT16_16((a),SHR((b),15)), SHR(MULT16_16((a),((b)&0x00007fff)),15)))

#define	MAC16_32_Q16(c, a, b) ADD32((c),ADD32(MULT16_16((a),SHR((b),16)), SHR(MULT16_16SU((a),((b)&0x0000ffff)),16)))

#define	MULT16_16_Q11_32(a, b) (SHR(MULT16_16((a),(b)),11))

#define	MULT16_16_Q11(a, b) (SHR(MULT16_16((a),(b)),11))

#define	MULT16_16_Q13(a, b) (SHR(MULT16_16((a),(b)),13))

#define	MULT16_16_Q14(a, b) (SHR(MULT16_16((a),(b)),14))

#define	MULT16_16_Q15(a, b) (SHR(MULT16_16((a),(b)),15))

#define	MULT16_16_P13(a, b) (SHR(ADD32(4096,MULT16_16((a),(b))),13))

#define	MULT16_16_P14(a, b) (SHR(ADD32(8192,MULT16_16((a),(b))),14))

#define	MULT16_16_P15(a, b) (SHR(ADD32(16384,MULT16_16((a),(b))),15))

#define	DIV32_16(a, b) ((opus_val16)(((opus_val32)(a))/((opus_val16)(b))))

#define	DIV32(a, b) (((opus_val32)(a))/((opus_val32)(b)))

#define	SIG2WORD16(x) (SIG2WORD16_generic(x))

Detailed Description

Generic fixed-point operations.

Macro Definition Documentation

◆ ADD16

#define ADD16	(	a,
		b
	)	((opus_val16)((opus_val16)(a)+(opus_val16)(b)))

Add two 16-bit values

◆ ADD32

#define ADD32	(	a,
		b
	)	((opus_val32)(a)+(opus_val32)(b))

Add two 32-bit values

◆ DIV32

#define DIV32	(	a,
		b
	)	(((opus_val32)(a))/((opus_val32)(b)))

Divide a 32-bit value by a 32-bit value. Result fits in 32 bits

◆ DIV32_16

#define DIV32_16	(	a,
		b
	)	((opus_val16)(((opus_val32)(a))/((opus_val16)(b))))

Divide a 32-bit value by a 16-bit value. Result fits in 16 bits

◆ EXTEND32

#define EXTEND32 ( x ) ((opus_val32)(x))

Change a 16-bit value into a 32-bit value

◆ EXTRACT16

#define EXTRACT16 ( x ) ((opus_val16)(x))

Change a 32-bit value into a 16-bit value. The value is assumed to fit in 16-bit, otherwise the result is undefined

◆ HALF16

#define HALF16 ( x ) (SHR16(x,1))

Divide by two

◆ HALF32

#define HALF32 ( x ) (SHR32(x,1))

◆ MAC16_16

#define MAC16_16	(	c,
		a,
		b
	)	(ADD32((c),MULT16_16((a),(b))))

16x16 multiply-add where the result fits in 32 bits

◆ MAC16_32_Q15

#define MAC16_32_Q15	(	c,
		a,
		b
	)	ADD32((c),ADD32(MULT16_16((a),SHR((b),15)), SHR(MULT16_16((a),((b)&0x00007fff)),15)))

16x32 multiply, followed by a 15-bit shift right and 32-bit add. b must fit in 31 bits. Result fits in 32 bits.

◆ MAC16_32_Q16

#define MAC16_32_Q16	(	c,
		a,
		b
	)	ADD32((c),ADD32(MULT16_16((a),SHR((b),16)), SHR(MULT16_16SU((a),((b)&0x0000ffff)),16)))

16x32 multiplication, followed by a 16-bit shift right and 32-bit add. Results fits in 32 bits

◆ MULT16_16

#define MULT16_16	(	a,
		b
	)	(((opus_val32)(opus_val16)(a))*((opus_val32)(opus_val16)(b)))

16x16 multiplication where the result fits in 32 bits

◆ MULT16_16_16

#define MULT16_16_16	(	a,
		b
	)	((((opus_val16)(a))*((opus_val16)(b))))

16x16 multiplication where the result fits in 16 bits

◆ MULT16_16_P13

#define MULT16_16_P13	(	a,
		b
	)	(SHR(ADD32(4096,MULT16_16((a),(b))),13))

◆ MULT16_16_P14

#define MULT16_16_P14	(	a,
		b
	)	(SHR(ADD32(8192,MULT16_16((a),(b))),14))

◆ MULT16_16_P15

#define MULT16_16_P15	(	a,
		b
	)	(SHR(ADD32(16384,MULT16_16((a),(b))),15))

◆ MULT16_16_Q11

#define MULT16_16_Q11	(	a,
		b
	)	(SHR(MULT16_16((a),(b)),11))

◆ MULT16_16_Q11_32

#define MULT16_16_Q11_32	(	a,
		b
	)	(SHR(MULT16_16((a),(b)),11))

◆ MULT16_16_Q13

#define MULT16_16_Q13	(	a,
		b
	)	(SHR(MULT16_16((a),(b)),13))

◆ MULT16_16_Q14

#define MULT16_16_Q14	(	a,
		b
	)	(SHR(MULT16_16((a),(b)),14))

◆ MULT16_16_Q15

#define MULT16_16_Q15	(	a,
		b
	)	(SHR(MULT16_16((a),(b)),15))

◆ MULT16_16SU

#define MULT16_16SU	(	a,
		b
	)	((opus_val32)(opus_val16)(a)*(opus_val32)(opus_uint16)(b))

Multiply a 16-bit signed value by a 16-bit unsigned value. The result is a 32-bit signed value

◆ MULT16_32_P16

#define MULT16_32_P16	(	a,
		b
	)	ADD32(MULT16_16((a),SHR((b),16)), PSHR(MULT16_16SU((a),((b)&0x0000ffff)),16))

16x32 multiplication, followed by a 16-bit shift right (round-to-nearest). Results fits in 32 bits

◆ MULT16_32_Q15

#define MULT16_32_Q15	(	a,
		b
	)	ADD32(SHL(MULT16_16((a),SHR((b),16)),1), SHR(MULT16_16SU((a),((b)&0x0000ffff)),15))

16x32 multiplication, followed by a 15-bit shift right. Results fits in 32 bits

◆ MULT16_32_Q16

#define MULT16_32_Q16	(	a,
		b
	)	ADD32(MULT16_16((a),SHR((b),16)), SHR(MULT16_16SU((a),((b)&0x0000ffff)),16))

16x32 multiplication, followed by a 16-bit shift right. Results fits in 32 bits

◆ MULT32_32_Q31

#define MULT32_32_Q31	(	a,
		b
	)	ADD32(ADD32(SHL(MULT16_16(SHR((a),16),SHR((b),16)),1), SHR(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),15)), SHR(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),15))

32x32 multiplication, followed by a 31-bit shift right. Results fits in 32 bits

◆ NEG16

#define NEG16 ( x ) (-(x))

Negate a 16-bit value

◆ NEG32

#define NEG32 ( x ) (-(x))

Negate a 32-bit value

◆ PSHR

#define PSHR	(	a,
		shift
	)	(SHR((a)+((EXTEND32(1)<<((shift))>>1)),shift))

◆ PSHR32

#define PSHR32	(	a,
		shift
	)	(SHR32((a)+((EXTEND32(1)<<((shift))>>1)),shift))

32-bit arithmetic shift right with rounding-to-nearest instead of rounding down

◆ QCONST16

#define QCONST16	(	x,
		bits
	)	((opus_val16)(.5+(x)*(((opus_val32)1)<<(bits))))

Compile-time conversion of float constant to 16-bit value

◆ QCONST32

#define QCONST32	(	x,
		bits
	)	((opus_val32)(.5+(x)*(((opus_val32)1)<<(bits))))

Compile-time conversion of float constant to 32-bit value

◆ ROUND16

#define ROUND16	(	x,
		a
	)	(EXTRACT16(PSHR32((x),(a))))

Shift by a and round-to-neareast 32-bit value. Result is a 16-bit value

◆ SATURATE

#define SATURATE	(	x,
		a
	)	(((x)>(a) ? (a) : (x)<-(a) ? -(a) : (x)))

◆ SATURATE16

#define SATURATE16 ( x ) (EXTRACT16((x)>32767 ? 32767 : (x)<-32768 ? -32768 : (x)))

◆ SHL

#define SHL	(	a,
		shift
	)	SHL32(a,shift)

◆ SHL16

#define SHL16	(	a,
		shift
	)	((opus_int16)((opus_uint16)(a)<<(shift)))

Arithmetic shift-left of a 16-bit value

◆ SHL32

#define SHL32	(	a,
		shift
	)	((opus_int32)((opus_uint32)(a)<<(shift)))

Arithmetic shift-left of a 32-bit value

◆ SHR

#define SHR	(	a,
		shift
	)	((a) >> (shift))

"RAW" macros, should not be used outside of this header file

◆ SHR16

#define SHR16	(	a,
		shift
	)	((a) >> (shift))

Arithmetic shift-right of a 16-bit value

◆ SHR32

#define SHR32	(	a,
		shift
	)	((a) >> (shift))

Arithmetic shift-right of a 32-bit value

◆ SIG2WORD16

#define SIG2WORD16 ( x ) (SIG2WORD16_generic(x))

◆ SUB16

#define SUB16	(	a,
		b
	)	((opus_val16)(a)-(opus_val16)(b))

Subtract two 16-bit values

◆ SUB32

#define SUB32	(	a,
		b
	)	((opus_val32)(a)-(opus_val32)(b))

Subtract two 32-bit values

◆ VSHR32

#define VSHR32	(	a,
		shift
	)	(((shift)>0) ? SHR32(a, shift) : SHL32(a, -(shift)))

32-bit arithmetic shift right where the argument can be negative

Macros