UDocumentation UE5.7 10.02.2026 (Source)
API documentation for Unreal Engine 5.7
Classes | Macros | Typedefs | Functions
varbits.h File Reference
#include "rrCore.h"

Go to the source code of this file.

Classes

struct  _VARBITS
 
struct  _VARBITSEND
 
struct  _VARBITSB
 

Macros

#define BITSTYPE   U32
 
#define BITSTYPELEN   32
 
#define BITSTYPEBYTES   4
 
#define BITSTOPMASK   (1UL<<(BITSTYPELEN-1))
 
#define VarBitsOpen(vb, pointer)   { (vb).cur=(vb).init=pointer; (vb).bits=(vb).bitlen=0; }
 
#define VarBitsLocalOpen(vb, pointer)   { vb##cur=pointer; vb##bits=vb##bitlen=0; }
 
#define VARBITSTEMP   BITSTYPE
 
#define VarBitsPut(vb, val, size)   { U32 __s=size; U32 __v=(val)&VarBitsLens[__s]; (vb).bits|=__v<<((vb).bitlen); (vb).bitlen+=__s; if ((vb).bitlen>=32) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bitlen-=32; (vb).bits=0; if ((vb).bitlen) { (vb).bits=__v>>(__s-(vb).bitlen); } } }
 
#define VarBitsPut1(vb, boolean)   { if (boolean) (vb).bits|=(1<<(vb).bitlen); if ((++(vb).bitlen)==32) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }
 
#define VarBitsPuta1(vb)   { (vb).bits|=(1<<(vb).bitlen); if ((++(vb).bitlen)==32) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }
 
#define VarBitsPuta0(vb)   { if ((++(vb).bitlen)==32) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }
 
#define VarBitsPutAlign(vb)   { U32 __s2=(32-(vb).bitlen)&31; if (__s2) { VarBitsPut((vb),0,__s2); } }
 
#define VarBitsFlushtoMemOnly(vb)   { if (((vb).bitlen)) { *((U32*)(vb).cur)=(vb).bits; } }
 
#define VarBitsConvertPutToGet(gvb, pvb)   { if (((pvb).bitlen)) { (gvb).bits=(*((U32*)(pvb).cur))>>(pvb).bitlen; (gvb).bitlen=BITSTYPELEN-(pvb).bitlen; (gvb).cur=((char*)((pvb).cur)+4); } else { (gvb).bits=0; (gvb).bitlen=0; (gvb).cur=(pvb).cur; } (gvb).init=(pvb).init; }
 
#define VarBitsFlush(vb)   VarBitsPutAlign(vb)
 
#define VarBitsSize(vb)   ((U32)( (((char*)(vb).cur)-((char*)(vb).init))*8 +(vb).bitlen ))
 
#define getbitlevelconst(level)
 
#define VarBitsGetAlign(vb)   { (vb).bitlen=0; }
 
#define VarBitsPos(vb)   ((U32)( (((U8*)(vb).cur)-((U8*)(vb).init))*8-(vb).bitlen ))
 
#define GetBitsLen(val)   (((U32)0xffffffff)>>(U32)(32-(val)))
 
#define VarBitsGet1(vb, i)
 
#define VarBitsGet1LE(vb, i)
 
#define VarBitsGet(v, typ, vb, len)
 
#define VarBitsGetWithCheck(v, typ, vb, len, endp, dowhat)
 
#define VarBitsGetWithCheckBE(v, typ, vb, len, endp, dowhat)
 
#define VarBitsGetWithCheckLE(v, typ, vb, len, endp, dowhat)
 
#define VarBitsPeek(v, typ, vb, len)
 
#define VarBitsGetLE(v, typ, vb, len)
 
#define VarBitsUse(vb, len)
 
#define VARBITSLOCAL(name)   void * name##cur; BITSTYPE name##bits; U32 name##bitlen
 
#define VarBitsLocalGet(v, typ, vb, len)
 
#define VarBitsLocalGetWithCheckBase(v, typ, vb, len, mask, endp, dowhat, load)
 
#define radloadbitsnative(ptr)   (*((BITSTYPE* RADRESTRICT)(ptr)))
 
#define VarBitsLocalGetWithCheck(v, typ, vb, len, endp, dowhat)   VarBitsLocalGetWithCheckBase(v,typ,vb,len,GetBitsLen(len),endp,dowhat,radloadbitsnative)
 
#define VarBitsLocalGetWithCheckBE(v, typ, vb, len, endp, dowhat)   VarBitsLocalGetWithCheckBase(v,typ,vb,len,GetBitsLen(len),endp,dowhat,radloadu32ptrBE)
 
#define VarBitsLocalGetWithCheckLE(v, typ, vb, len, endp, dowhat)   VarBitsLocalGetWithCheckBase(v,typ,vb,len,GetBitsLen(len),endp,dowhat,radloadu32ptr)
 
#define VarBitsLocalGetWithCheckM(v, typ, vb, len, mask, endp, dowhat)   VarBitsLocalGetWithCheckBase(v,typ,vb,len,mask,endp,dowhat,radloadbitsnative)
 
#define VarBitsLocalGetWithCheckMBE(v, typ, vb, len, mask, endp, dowhat)   VarBitsLocalGetWithCheckBase(v,typ,vb,len,mask,endp,dowhat,radloadu32ptrBE)
 
#define VarBitsLocalGetWithCheckMLE(v, typ, vb, len, mask, endp, dowhat)   VarBitsLocalGetWithCheckBase(v,typ,vb,len,mask,endp,dowhat,radloadu32ptr)
 
#define VarBitsLocalFill1WithCheckBase(vb, endp, cond, dowhat, load)
 
#define VarBitsLocalGet1WithCheckBase(v, vb, endp, dowhat, load)
 
#define VarBitsLocalFill1WithCheck(vb, endp, cond, dowhat)   VarBitsLocalFill1WithCheckBase(vb,endp,cond,dowhat,radloadbitsnative)
 
#define VarBitsLocalFill1WithCheckBE(vb, endp, cond, dowhat)   VarBitsLocalFill1WithCheckBase(vb,endp,cond,dowhat,radloadu32ptrBE)
 
#define VarBitsLocalFill1WithCheckLE(vb, endp, cond, dowhat)   VarBitsLocalFill1WithCheckBase(vb,endp,cond,dowhat,radloadu32ptr)
 
#define VarBitsLocalGet1WithCheck(v, vb, endp, dowhat)   VarBitsLocalGet1WithCheckBase(v,vb,endp,dowhat,radloadbitsnative)
 
#define VarBitsLocalGet1WithCheckBE(v, vb, endp, dowhat)   VarBitsLocalGet1WithCheckBase(v,vb,endp,dowhat,radloadu32ptrBE)
 
#define VarBitsLocalGet1WithCheckLE(v, vb, endp, dowhat)   VarBitsLocalGet1WithCheckBase(v,vb,endp,dowhat,radloadu32ptr)
 
#define VarBitsLocalGetIfxSM(v, typ, vb, len, i, x, mask)
 
#define VarBitsLocalGetIfx(v, typ, vb, len, i, x)    VarBitsLocalGetIfxSM(v,typ,vb,len,i,x,&GetBitLen(len))
 
#define VarBitsLocalGetIfxNM(v, typ, vb, len, i, x)    VarBitsLocalGetIfxSM(v,typ,vb,len,i,x, )
 
#define VarBitsLocalPeek(v, typ, vb, len)
 
#define VarBitsLocalGet1BE(vb, i)
 
#define VarBitsLocalGet1LE(vb, i)
 
#define VarBitsLocalMaskFromMaskAndUse1(omask, vb, imask)
 
#define VarBitsLocalGet1(vb, i)
 
#define VarBitsLocalUse(vb, len)
 
#define VarBitsLocalPos(vb, origvb)   ((U32)( (((char*)vb##cur)-((char*)(origvb)->init))*8 +(32-vb##bitlen) ))
 
#define VarBitsCopyToLocal(local, vb)   local##cur = (vb).cur; local##bits = (vb).bits; local##bitlen = (vb).bitlen;
 
#define VarBitsCopyFromLocal(vb, local)   (vb).cur = local##cur; (vb).bits = local##bits; (vb).bitlen = local##bitlen;
 
#define CLASSIFY_SIGN(val)   ( (((U32)((S32)(val))) >> 31 ) + ((((U32)(-(S32)(val))) >> 30 ) & 2 ) )
 
#define VarBitsBPutOpen(vb, ptr)   { (vb).cur=(vb).init=(void *)(ptr); (vb).bits=(vb).bitlen=0; (vb).isPut = 1; }
 
#define VarBitsBGetOpen(vb, ptr)   { (vb).cur=(vb).init=(void *)(ptr); (vb).bits=(vb).bitlen=0; (vb).isPut = 0; }
 
#define VarBitsBPut(vb, val, size)
 
#define VarBitsBPuta1(vb)   { (vb).bits = (vb).bits + (vb).bits + 1; if ((++(vb).bitlen)==BITSTYPELEN) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }
 
#define VarBitsBPuta0(vb)   { (vb).bits <<= 1; if ((++(vb).bitlen)==BITSTYPELEN) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }
 
#define VarBitsBPut1(vb, bit)   { (vb).bits = (vb).bits + (vb).bits + ((bit)?1:0); if ((++(vb).bitlen)==BITSTYPELEN) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }
 
#define VarBitsBPutAlign(vb)   { U32 __s2=(32-(vb).bitlen)&31; if (__s2) { VarBitsBPut((vb),0,__s2); } }
 
#define VarBitsBPutFlush(vb)   VarBitsBPutAlign(vb)
 
#define VarBitsBGetAlign(vb)   { (vb).bitlen=0; }
 
#define VarBitsBPutSize(vb)   ((U32)( (((char*)(vb).cur)-((char*)(vb).init))*8 +(vb).bitlen ))
 
#define VarBitsBGetSize(vb)   ((U32)( (((char*)(vb).cur)-((char*)(vb).init))*8 -(vb).bitlen ))
 
#define VarBitsBGet(v, typ, vb, len)
 
#define VarBitsBPeek(v, typ, vb, len)
 
#define VarBitsBUse(vb, len)
 
#define VarBitsBGet1(vb, temp_u32)
 

Typedefs

typedef struct _VARBITS VARBITS
 
typedef struct _VARBITSEND VARBITSEND
 
typedef struct _VARBITSB VARBITSB
 

Functions

RADDECLAREDATA const RAD_ALIGN (U32, VarBitsLens[33], 32)
 
RADDEFFUNC void VarBitsCopy (VARBITS *dest, VARBITS *src, U32 size)
 

Macro Definition Documentation

◆ BITSTOPMASK

#define BITSTOPMASK   (1UL<<(BITSTYPELEN-1))

◆ BITSTYPE

#define BITSTYPE   U32

◆ BITSTYPEBYTES

#define BITSTYPEBYTES   4

◆ BITSTYPELEN

#define BITSTYPELEN   32

◆ CLASSIFY_SIGN

#define CLASSIFY_SIGN (   val)    ( (((U32)((S32)(val))) >> 31 ) + ((((U32)(-(S32)(val))) >> 30 ) & 2 ) )

◆ getbitlevelconst

#define getbitlevelconst (   level)
Value:
( \
(((level)< 1)?0: \
(((level)< 2)?1: \
(((level)< 4)?2: \
(((level)< 8)?3: \
(((level)< 16)?4: \
(((level)< 32)?5: \
(((level)< 64)?6: \
(((level)< 128)?7: \
(((level)< 256)?8: \
(((level)< 512)?9: \
(((level)< 1024)?10: \
(((level)< 2048)?11: \
(((level)< 4096)?12: \
(((level)< 8192)?13: \
(((level)<16384)?14: \
(((level)<32768)?15: \
(((level)<65536)?16:sizeof(char[65535-level]) \
))))))))))))))))) \
)
level
GLenum GLuint GLint level
Definition AndroidOpenGLFunctions.h:46

◆ GetBitsLen

#define GetBitsLen (   val)    (((U32)0xffffffff)>>(U32)(32-(val)))

◆ radloadbitsnative

#define radloadbitsnative (   ptr)    (*((BITSTYPE* RADRESTRICT)(ptr)))

◆ VarBitsBGet

#define VarBitsBGet (   v,
  typ,
  vb,
  len 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)((vb).cur)); \
v=(typ)((((vb).bits)|(nb>>((vb).bitlen)))>>(BITSTYPELEN-len));\
((vb).bits)=nb<<((len)-((vb).bitlen)); \
((vb).bitlen)=((vb).bitlen)+BITSTYPELEN-(len); \
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES; \
} else { \
v=(typ)(((vb).bits)>>(BITSTYPELEN-len)); \
((vb).bits)<<=(len); \
((vb).bitlen)-=(len); \
v &= (len)?0xffffffff:0; \
} \
}
RADRESTRICT
#define RADRESTRICT
Definition egttypes.h:282
StaticCastSharedRef
UE_FORCEINLINE_HINT TSharedRef< CastToType, Mode > StaticCastSharedRef(TSharedRef< CastFromType, Mode > const &InSharedRef)
Definition SharedPointer.h:127
v
float v
Definition radaudio_mdct.cpp:62
BITSTYPE
#define BITSTYPE
Definition varbits.h:45
BITSTYPEBYTES
#define BITSTYPEBYTES
Definition varbits.h:47
BITSTYPELEN
#define BITSTYPELEN
Definition varbits.h:46

◆ VarBitsBGet1

#define VarBitsBGet1 (   vb,
  temp_u32 
)
Value:
( \
((vb).bitlen==0)? \
( \
temp_u32=*((BITSTYPE* RADRESTRICT)((vb).cur)),\
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES, \
((vb).bits)=((BITSTYPE)temp_u32)<<1, \
((vb).bitlen)=(BITSTYPELEN-1) \
):( \
temp_u32=((vb).bits), \
((vb).bits)<<=1, \
--((vb).bitlen) \
), \
(temp_u32>>(BITSTYPELEN-1)) \
)

◆ VarBitsBGetAlign

#define VarBitsBGetAlign (   vb)    { (vb).bitlen=0; }

◆ VarBitsBGetOpen

#define VarBitsBGetOpen (   vb,
  ptr 
)    { (vb).cur=(vb).init=(void *)(ptr); (vb).bits=(vb).bitlen=0; (vb).isPut = 0; }

◆ VarBitsBGetSize

#define VarBitsBGetSize (   vb)    ((U32)( (((char*)(vb).cur)-((char*)(vb).init))*8 -(vb).bitlen ))

◆ VarBitsBPeek

#define VarBitsBPeek (   v,
  typ,
  vb,
  len 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)((vb).cur)); \
v=(typ)((((vb).bits)|(nb>>((vb).bitlen)))>>(BITSTYPELEN-len));\
} else { \
v=(typ)(((vb).bits)>>(BITSTYPELEN-len)); \
} \
}

◆ VarBitsBPut

#define VarBitsBPut (   vb,
  val,
  size 
)
Value:
do { U32 __s=size; U32 __v=(val); \
radassert( __v < (1UL<<__s) ); \
if ((vb).bitlen+__s >=BITSTYPELEN) { U32 __r = __s + (vb).bitlen - BITSTYPELEN; \
(vb).bits <<= (BITSTYPELEN-(vb).bitlen); (vb).bits |= __v >> __r; \
*((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); \
(vb).bitlen = __r; (vb).bits = __v&VarBitsLens[__r]; } \
else { (vb).bits = ((vb).bits<<__s) | __v; (vb).bitlen+=__s; } } while(0)
U32
RAD_U32 U32
Definition egttypes.h:501

◆ VarBitsBPut1

#define VarBitsBPut1 (   vb,
  bit 
)    { (vb).bits = (vb).bits + (vb).bits + ((bit)?1:0); if ((++(vb).bitlen)==BITSTYPELEN) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }

◆ VarBitsBPuta0

#define VarBitsBPuta0 (   vb)    { (vb).bits <<= 1; if ((++(vb).bitlen)==BITSTYPELEN) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }

◆ VarBitsBPuta1

#define VarBitsBPuta1 (   vb)    { (vb).bits = (vb).bits + (vb).bits + 1; if ((++(vb).bitlen)==BITSTYPELEN) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }

◆ VarBitsBPutAlign

#define VarBitsBPutAlign (   vb)    { U32 __s2=(32-(vb).bitlen)&31; if (__s2) { VarBitsBPut((vb),0,__s2); } }

◆ VarBitsBPutFlush

#define VarBitsBPutFlush (   vb)    VarBitsBPutAlign(vb)

◆ VarBitsBPutOpen

#define VarBitsBPutOpen (   vb,
  ptr 
)    { (vb).cur=(vb).init=(void *)(ptr); (vb).bits=(vb).bitlen=0; (vb).isPut = 1; }

◆ VarBitsBPutSize

#define VarBitsBPutSize (   vb)    ((U32)( (((char*)(vb).cur)-((char*)(vb).init))*8 +(vb).bitlen ))

◆ VarBitsBUse

#define VarBitsBUse (   vb,
  len 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)((vb).cur)); \
((vb).bits)=nb<<((len)-((vb).bitlen)); \
((vb).bitlen)=((vb).bitlen)+BITSTYPELEN-(len); \
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES; \
} else { \
((vb).bits)<<=(len); \
((vb).bitlen)-=(len); \
} \
}

◆ VarBitsConvertPutToGet

#define VarBitsConvertPutToGet (   gvb,
  pvb 
)    { if (((pvb).bitlen)) { (gvb).bits=(*((U32*)(pvb).cur))>>(pvb).bitlen; (gvb).bitlen=BITSTYPELEN-(pvb).bitlen; (gvb).cur=((char*)((pvb).cur)+4); } else { (gvb).bits=0; (gvb).bitlen=0; (gvb).cur=(pvb).cur; } (gvb).init=(pvb).init; }

◆ VarBitsCopyFromLocal

#define VarBitsCopyFromLocal (   vb,
  local 
)    (vb).cur = local##cur; (vb).bits = local##bits; (vb).bitlen = local##bitlen;

◆ VarBitsCopyToLocal

#define VarBitsCopyToLocal (   local,
  vb 
)    local##cur = (vb).cur; local##bits = (vb).bits; local##bitlen = (vb).bitlen;

◆ VarBitsFlush

#define VarBitsFlush (   vb)    VarBitsPutAlign(vb)

◆ VarBitsFlushtoMemOnly

#define VarBitsFlushtoMemOnly (   vb)    { if (((vb).bitlen)) { *((U32*)(vb).cur)=(vb).bits; } }

◆ VarBitsGet

#define VarBitsGet (   v,
  typ,
  vb,
  len 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)((vb).cur)); \
v=(typ)((((vb).bits)|(nb<<((vb).bitlen)))&GetBitsLen(len)); \
((vb).bits)=nb>>((len)-((vb).bitlen)); \
((vb).bitlen)=((vb).bitlen)+BITSTYPELEN-(len); \
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES; \
} else { \
v=(typ)(((vb).bits)&GetBitsLen(len)); \
((vb).bits)>>=(len); \
((vb).bitlen)-=(len); \
} \
}
GetBitsLen
#define GetBitsLen(val)
Definition varbits.h:246

◆ VarBitsGet1

#define VarBitsGet1 (   vb,
  i 
)
Value:
( \
((vb).bitlen==0)? \
( \
i=*((BITSTYPE* RADRESTRICT)((vb).cur)), \
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES, \
((vb).bits)=((BITSTYPE)i)>>1, \
((vb).bitlen)=(BITSTYPELEN-1) \
):( \
i=((vb).bits), \
((vb).bits)>>=1, \
--((vb).bitlen) \
),(i&1) \
)

◆ VarBitsGet1LE

#define VarBitsGet1LE (   vb,
  i 
)
Value:
( \
((vb).bitlen==0)? \
( \
i=radloadu32ptr((vb).cur), \
((vb).cur)=((char*)((vb).cur))+4, \
((vb).bits)=((U32)i)>>1, \
((vb).bitlen)=31 \
):( \
i=((vb).bits), \
((vb).bits)>>=1, \
--((vb).bitlen) \
),(i&1) \
)

◆ VarBitsGetAlign

#define VarBitsGetAlign (   vb)    { (vb).bitlen=0; }

◆ VarBitsGetLE

#define VarBitsGetLE (   v,
  typ,
  vb,
  len 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register U32 nb=radloadu32ptr((vb).cur); \
v=(typ)((((vb).bits)|(nb<<((vb).bitlen)))&GetBitsLen(len)); \
((vb).bits)=nb>>((len)-((vb).bitlen)); \
((vb).bitlen)=((vb).bitlen)+32-(len); \
((vb).cur)=((char*)((vb).cur))+4; \
} else { \
v=(typ)(((vb).bits)&GetBitsLen(len)); \
((vb).bits)>>=(len); \
((vb).bitlen)-=(len); \
} \
}

◆ VarBitsGetWithCheck

#define VarBitsGetWithCheck (   v,
  typ,
  vb,
  len,
  endp,
  dowhat 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb; \
if ( ( (U8*)((vb).cur) ) >= ( (U8*) (endp) ) ) dowhat \
nb=*((BITSTYPE* RADRESTRICT)((vb).cur)); \
v=(typ)((((vb).bits)|(nb<<((vb).bitlen)))&GetBitsLen(len)); \
((vb).bits)=nb>>((len)-((vb).bitlen)); \
((vb).bitlen)=((vb).bitlen)+BITSTYPELEN-(len); \
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES; \
} else { \
v=(typ)(((vb).bits)&GetBitsLen(len)); \
((vb).bits)>>=(len); \
((vb).bitlen)-=(len); \
} \
}
U8
RAD_U8 U8
Definition egttypes.h:481

◆ VarBitsGetWithCheckBE

#define VarBitsGetWithCheckBE (   v,
  typ,
  vb,
  len,
  endp,
  dowhat 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb; \
if ( ( (U8*)((vb).cur) ) >= ( (U8*) (endp) ) ) dowhat \
nb=radloadu32ptrBE((vb).cur); \
v=(typ)((((vb).bits)|(nb<<((vb).bitlen)))&GetBitsLen(len)); \
((vb).bits)=nb>>((len)-((vb).bitlen)); \
((vb).bitlen)=((vb).bitlen)+BITSTYPELEN-(len); \
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES; \
} else { \
v=(typ)(((vb).bits)&GetBitsLen(len)); \
((vb).bits)>>=(len); \
((vb).bitlen)-=(len); \
} \
}

◆ VarBitsGetWithCheckLE

#define VarBitsGetWithCheckLE (   v,
  typ,
  vb,
  len,
  endp,
  dowhat 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb; \
if ( ( (U8*)((vb).cur) ) >= ( (U8*) (endp) ) ) dowhat \
nb=radloadu32ptr((vb).cur); \
v=(typ)((((vb).bits)|(nb<<((vb).bitlen)))&GetBitsLen(len)); \
((vb).bits)=nb>>((len)-((vb).bitlen)); \
((vb).bitlen)=((vb).bitlen)+BITSTYPELEN-(len); \
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES; \
} else { \
v=(typ)(((vb).bits)&GetBitsLen(len)); \
((vb).bits)>>=(len); \
((vb).bitlen)-=(len); \
} \
}

◆ VARBITSLOCAL

#define VARBITSLOCAL (   name)    void * name##cur; BITSTYPE name##bits; U32 name##bitlen

◆ VarBitsLocalFill1WithCheck

#define VarBitsLocalFill1WithCheck (   vb,
  endp,
  cond,
  dowhat 
)    VarBitsLocalFill1WithCheckBase(vb,endp,cond,dowhat,radloadbitsnative)

◆ VarBitsLocalFill1WithCheckBase

#define VarBitsLocalFill1WithCheckBase (   vb,
  endp,
  cond,
  dowhat,
  load 
)
Value:
{ \
if ((vb##bitlen)==0 && (cond)) { \
if ( ( (U8*)(vb##cur) ) >= ( (U8*) (endp) ) ) dowhat \
(vb##bits)=load(vb##cur); \
(vb##cur)=((char*)(vb##cur))+BITSTYPEBYTES; \
(vb##bitlen)=(BITSTYPELEN); \
} \
}

◆ VarBitsLocalFill1WithCheckBE

#define VarBitsLocalFill1WithCheckBE (   vb,
  endp,
  cond,
  dowhat 
)    VarBitsLocalFill1WithCheckBase(vb,endp,cond,dowhat,radloadu32ptrBE)

◆ VarBitsLocalFill1WithCheckLE

#define VarBitsLocalFill1WithCheckLE (   vb,
  endp,
  cond,
  dowhat 
)    VarBitsLocalFill1WithCheckBase(vb,endp,cond,dowhat,radloadu32ptr)

◆ VarBitsLocalGet

#define VarBitsLocalGet (   v,
  typ,
  vb,
  len 
)
Value:
{ \
if ((vb##bitlen)<len) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)(vb##cur)); \
v=(typ)(((vb##bits)|(nb<<(vb##bitlen)))&GetBitsLen(len)); \
(vb##bits)=nb>>((len)-(vb##bitlen)); \
(vb##bitlen)=(vb##bitlen)+BITSTYPELEN-(len); \
(vb##cur)=((char*)(vb##cur))+BITSTYPEBYTES; \
} else { \
v=(typ)((vb##bits)&GetBitsLen(len)); \
(vb##bits)>>=(len); \
(vb##bitlen)-=(len); \
} \
}

◆ VarBitsLocalGet1

#define VarBitsLocalGet1 (   vb,
  i 
)
Value:
( \
(vb##bitlen==0)? \
( \
i=*((BITSTYPE* RADRESTRICT)(vb##cur)), \
(vb##cur)=((char*)(vb##cur))+BITSTYPEBYTES, \
(vb##bits)=((BITSTYPE)i)>>1, \
(vb##bitlen)=(BITSTYPELEN-1) \
):( \
i=(vb##bits), \
(vb##bits)>>=1, \
--(vb##bitlen) \
),(i&1) \
)

◆ VarBitsLocalGet1BE

#define VarBitsLocalGet1BE (   vb,
  i 
)
Value:
( \
(vb##bitlen==0)? \
( \
i=radloadu32ptrBE(vb##cur), \
(vb##cur)=((char*)(vb##cur))+BITSTYPEBYTES, \
(vb##bits)=((BITSTYPE)i)>>1, \
(vb##bitlen)=(BITSTYPELEN-1) \
):( \
i=(vb##bits), \
(vb##bits)>>=1, \
--(vb##bitlen) \
),(i&1) \
)

◆ VarBitsLocalGet1LE

#define VarBitsLocalGet1LE (   vb,
  i 
)
Value:
( \
(vb##bitlen==0)? \
( \
i=radloadu32ptr(vb##cur), \
(vb##cur)=((char*)(vb##cur))+BITSTYPEBYTES, \
(vb##bits)=((BITSTYPE)i)>>1, \
(vb##bitlen)=(BITSTYPELEN-1) \
):( \
i=(vb##bits), \
(vb##bits)>>=1, \
--(vb##bitlen) \
),(i&1) \
)

◆ VarBitsLocalGet1WithCheck

#define VarBitsLocalGet1WithCheck (   v,
  vb,
  endp,
  dowhat 
)    VarBitsLocalGet1WithCheckBase(v,vb,endp,dowhat,radloadbitsnative)

◆ VarBitsLocalGet1WithCheckBase

#define VarBitsLocalGet1WithCheckBase (   v,
  vb,
  endp,
  dowhat,
  load 
)
Value:
{ \
VarBitsLocalFill1WithCheckBase(vb,endp,1,dowhat,load) \
--(vb##bitlen); \
v=(vb##bits); \
(vb##bits)>>=1; \
v&=1; \
}

◆ VarBitsLocalGet1WithCheckBE

#define VarBitsLocalGet1WithCheckBE (   v,
  vb,
  endp,
  dowhat 
)    VarBitsLocalGet1WithCheckBase(v,vb,endp,dowhat,radloadu32ptrBE)

◆ VarBitsLocalGet1WithCheckLE

#define VarBitsLocalGet1WithCheckLE (   v,
  vb,
  endp,
  dowhat 
)    VarBitsLocalGet1WithCheckBase(v,vb,endp,dowhat,radloadu32ptr)

◆ VarBitsLocalGetIfx

#define VarBitsLocalGetIfx (   v,
  typ,
  vb,
  len,
  i,
  x 
)     VarBitsLocalGetIfxSM(v,typ,vb,len,i,x,&GetBitLen(len))

◆ VarBitsLocalGetIfxNM

#define VarBitsLocalGetIfxNM (   v,
  typ,
  vb,
  len,
  i,
  x 
)     VarBitsLocalGetIfxSM(v,typ,vb,len,i,x, )

◆ VarBitsLocalGetIfxSM

#define VarBitsLocalGetIfxSM (   v,
  typ,
  vb,
  len,
  i,
  x,
  mask 
)

◆ VarBitsLocalGetWithCheck

#define VarBitsLocalGetWithCheck (   v,
  typ,
  vb,
  len,
  endp,
  dowhat 
)    VarBitsLocalGetWithCheckBase(v,typ,vb,len,GetBitsLen(len),endp,dowhat,radloadbitsnative)

◆ VarBitsLocalGetWithCheckBase

#define VarBitsLocalGetWithCheckBase (   v,
  typ,
  vb,
  len,
  mask,
  endp,
  dowhat,
  load 
)
Value:
{ \
if ((vb##bitlen)<len) { \
register BITSTYPE nb; \
if ( ( (U8*)(vb##cur) ) >= ( (U8*) (endp) ) ) dowhat \
nb=load(vb##cur); \
v=(typ)(((vb##bits)|(nb<<(vb##bitlen)))&(mask)); \
(vb##bits)=nb>>((len)-(vb##bitlen)); \
(vb##bitlen)=(vb##bitlen)+BITSTYPELEN-(len); \
(vb##cur)=((char*)(vb##cur))+BITSTYPEBYTES; \
} else { \
v=(typ)((vb##bits)&(mask)); \
(vb##bits)>>=(len); \
(vb##bitlen)-=(len); \
} \
}

◆ VarBitsLocalGetWithCheckBE

#define VarBitsLocalGetWithCheckBE (   v,
  typ,
  vb,
  len,
  endp,
  dowhat 
)    VarBitsLocalGetWithCheckBase(v,typ,vb,len,GetBitsLen(len),endp,dowhat,radloadu32ptrBE)

◆ VarBitsLocalGetWithCheckLE

#define VarBitsLocalGetWithCheckLE (   v,
  typ,
  vb,
  len,
  endp,
  dowhat 
)    VarBitsLocalGetWithCheckBase(v,typ,vb,len,GetBitsLen(len),endp,dowhat,radloadu32ptr)

◆ VarBitsLocalGetWithCheckM

#define VarBitsLocalGetWithCheckM (   v,
  typ,
  vb,
  len,
  mask,
  endp,
  dowhat 
)    VarBitsLocalGetWithCheckBase(v,typ,vb,len,mask,endp,dowhat,radloadbitsnative)

◆ VarBitsLocalGetWithCheckMBE

#define VarBitsLocalGetWithCheckMBE (   v,
  typ,
  vb,
  len,
  mask,
  endp,
  dowhat 
)    VarBitsLocalGetWithCheckBase(v,typ,vb,len,mask,endp,dowhat,radloadu32ptrBE)

◆ VarBitsLocalGetWithCheckMLE

#define VarBitsLocalGetWithCheckMLE (   v,
  typ,
  vb,
  len,
  mask,
  endp,
  dowhat 
)    VarBitsLocalGetWithCheckBase(v,typ,vb,len,mask,endp,dowhat,radloadu32ptr)

◆ VarBitsLocalMaskFromMaskAndUse1

#define VarBitsLocalMaskFromMaskAndUse1 (   omask,
  vb,
  imask 
)
Value:
if (vb##bitlen==0) \
{ \
(vb##bits)=*((BITSTYPE* RADRESTRICT)(vb##cur)); \
(vb##bitlen)=BITSTYPELEN; \
(vb##cur)=((char*)(vb##cur))+BITSTYPEBYTES; \
} \
(vb##bitlen)+=imask; \
omask=(((S32)(vb##bits)<<31)>>31)&imask; \
(vb##bits)=((vb##bits>>1)&imask)|(vb##bits&~imask); \
S32
RAD_S32 S32
Definition egttypes.h:496

◆ VarBitsLocalOpen

#define VarBitsLocalOpen (   vb,
  pointer 
)    { vb##cur=pointer; vb##bits=vb##bitlen=0; }

◆ VarBitsLocalPeek

#define VarBitsLocalPeek (   v,
  typ,
  vb,
  len 
)
Value:
{ \
if ((vb##bitlen)<(len)) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)(vb##cur)); \
v=(typ)(((vb##bits)|(nb<<(vb##bitlen)))&GetBitsLen(len)); \
} else { \
v=(typ)((vb##bits)&GetBitsLen(len)); \
} \
}

◆ VarBitsLocalPos

#define VarBitsLocalPos (   vb,
  origvb 
)    ((U32)( (((char*)vb##cur)-((char*)(origvb)->init))*8 +(32-vb##bitlen) ))

◆ VarBitsLocalUse

#define VarBitsLocalUse (   vb,
  len 
)
Value:
{ \
if ((vb##bitlen)<(len)) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)(vb##cur)); \
(vb##bits)=nb>>((len)-(vb##bitlen)); \
(vb##bitlen)=(vb##bitlen)+BITSTYPELEN-(len); \
(vb##cur)=((char*)(vb##cur))+BITSTYPEBYTES; \
} else { \
(vb##bits)>>=(len); \
(vb##bitlen)-=(len); \
} \
}

◆ VarBitsOpen

#define VarBitsOpen (   vb,
  pointer 
)    { (vb).cur=(vb).init=pointer; (vb).bits=(vb).bitlen=0; }

◆ VarBitsPeek

#define VarBitsPeek (   v,
  typ,
  vb,
  len 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)((vb).cur)); \
v=(typ)((((vb).bits)|(nb<<((vb).bitlen)))&GetBitsLen(len)); \
} else { \
v=(typ)(((vb).bits)&GetBitsLen(len)); \
} \
}

◆ VarBitsPos

#define VarBitsPos (   vb)    ((U32)( (((U8*)(vb).cur)-((U8*)(vb).init))*8-(vb).bitlen ))

◆ VarBitsPut

#define VarBitsPut (   vb,
  val,
  size 
)    { U32 __s=size; U32 __v=(val)&VarBitsLens[__s]; (vb).bits|=__v<<((vb).bitlen); (vb).bitlen+=__s; if ((vb).bitlen>=32) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bitlen-=32; (vb).bits=0; if ((vb).bitlen) { (vb).bits=__v>>(__s-(vb).bitlen); } } }

◆ VarBitsPut1

#define VarBitsPut1 (   vb,
  boolean 
)    { if (boolean) (vb).bits|=(1<<(vb).bitlen); if ((++(vb).bitlen)==32) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }

◆ VarBitsPuta0

#define VarBitsPuta0 (   vb)    { if ((++(vb).bitlen)==32) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }

◆ VarBitsPuta1

#define VarBitsPuta1 (   vb)    { (vb).bits|=(1<<(vb).bitlen); if ((++(vb).bitlen)==32) { *((U32*)(vb).cur)=(vb).bits; (vb).cur=((char*)((vb).cur)+4); (vb).bits=(vb).bitlen=0; } }

◆ VarBitsPutAlign

#define VarBitsPutAlign (   vb)    { U32 __s2=(32-(vb).bitlen)&31; if (__s2) { VarBitsPut((vb),0,__s2); } }

◆ VarBitsSize

#define VarBitsSize (   vb)    ((U32)( (((char*)(vb).cur)-((char*)(vb).init))*8 +(vb).bitlen ))

◆ VARBITSTEMP

#define VARBITSTEMP   BITSTYPE

◆ VarBitsUse

#define VarBitsUse (   vb,
  len 
)
Value:
{ \
if (((vb).bitlen)<(len)) { \
register BITSTYPE nb=*((BITSTYPE* RADRESTRICT)((vb).cur)); \
((vb).bits)=nb>>((len)-((vb).bitlen)); \
((vb).bitlen)=((vb).bitlen)+BITSTYPELEN-(len); \
((vb).cur)=((char*)((vb).cur))+BITSTYPEBYTES; \
} else { \
((vb).bits)>>=(len); \
((vb).bitlen)-=(len); \
} \
}

Typedef Documentation

◆ VARBITS

typedef struct _VARBITS VARBITS

◆ VARBITSB

typedef struct _VARBITSB VARBITSB

◆ VARBITSEND

typedef struct _VARBITSEND VARBITSEND

Function Documentation

◆ RAD_ALIGN()

RADDECLAREDATA const RAD_ALIGN ( U32  ,
VarBitsLens  [33],
32   
)

◆ VarBitsCopy()

RADDEFFUNC void VarBitsCopy ( VARBITS *  dest,
VARBITS *  src,
U32  size 
)