---

GLAST/LAT > DAQ and FSW > FSW > Doxygen Index > LDT / V0-0-0

Constituent: encdec     Tag: rad750

---

         

---

BTE.c File Reference

Binary Tree Encoding routines. More...

#include <stdio.h>
#include "LDT/BTE.h"

Include dependency graph for BTE.c:

Functions
__inline unsigned int	encode (unsigned int e, unsigned int w, unsigned int p1, unsigned int p3)
	Encodes the input word w into the output word e.
unsigned int __inline	BTE_wordCnts (unsigned int w, unsigned int pattern)
	Returns a packed 32-bit word, where each byte represents the count of the how times each of the 4 possible node values occurs.
unsigned int	BTE_wordEncode (unsigned int w, unsigned int pattern, unsigned int scheme_size)
	Encodes the original word and its higher level binary tree pattern returning a 32 bit output word. The algorithm is such that at most 32 bits are used, not counting the bits needed to encode the scheme.
unsigned int	BTE_wordPattern (unsigned int w)
	Prepares a pattern word which includes all but the lowest level of the binary tree.
unsigned int __inline	BTE_wordSizes (unsigned int w, unsigned int pattern)
	Computes the bit size of the encoded word using each of the 4 possible encoding schemes.
unsigned int	BTE_wordSchemeSize (unsigned int w, unsigned int pattern)
	Computes the optimal encoding scheme and size using of the 4 possible encoding schemes.
unsigned int	BTE_wordSize (unsigned int w, unsigned int pattern, unsigned int scheme)
	Computes the size using of the specified encoding schemes.
BTE_compressed	BTE_wordCompress (unsigned int w)
	Computes and returns the compressed word plus its size, in bits, plus the encoding scheme used.

---

Detailed Description

Binary Tree Encoding routines.

Author:

JJRussell - russell@slac.stanford.edu

Routines to encode bit strings using a binary tree

    CVS $Id: BTE.c,v 1.1.1.1 2005/09/23 06:41:07 russell Exp $

EXAMPLE The following shard of code shows how one ties these routines together to encode a 32 bit word, word.

     unsigned int pattern     = BTE_wordPatten     (word);
     unsigned int scheme_size = BTE_wordSchemeSize (word, pattern);
     unsigned int encoded     = BTE_wordEncode     (word, pattern, scheme);

---

Function Documentation

unsigned int BTE_wordCnts (  unsigned int  w, unsigned int  pattern )

Returns a packed 32-bit word, where each byte represents the count of the how times each of the 4 possible node values occurs. Returns: The packed 32-bit word Parameters: w  The word being encoded pattern  The precompiled pattern word The bytes are (from least to most signficant Count of Pattern 00, must be 0 Count of Pattern 01 Count of Pattern 10 Count of Pattern 11

BTE_compressed BTE_wordCompress (  unsigned int  w  )

Computes and returns the compressed word plus its size, in bits, plus the encoding scheme used. Returns: A BTE_compressed structure containing the compressed word plus its size, in bits, plus the encoding scheme used Parameters: w  The word to compress This is a convenience routine combining the BTE_wordPattern BTE_wordSchemeSize BTE_wordEncode While this routine is convenient, it does so at some cost. Each word is encoded according to the optimal scheme. This means the caller must make sure the encoding scheme is encoded along with each compressed word. The encoding of the encoding scheme itself costs some number of bits. For a collection of words to encode, it may be more optimal to pick a fixed scheme. The fixed scheme may be based on some apriori knowledge (one just picks a scheme) or one computes the size of the collection for each of the 4 schemes, then uses the scheme giving the smallest total size of the whole collection, to encode the whole collection.

Here is the call graph for this function:

unsigned int BTE_wordEncode (  unsigned int  w, unsigned int  pattern, unsigned int  scheme_size )

Encodes the original word and its higher level binary tree pattern returning a 32 bit output word. The algorithm is such that at most 32 bits are used, not counting the bits needed to encode the scheme. Parameters: w  The original 3 2-bit word that is to be encoded pattern  The higher level binary tree pattern word. This is generally computed by calling BTE_wordPrepare(). scheme_size  The encoding scheme to be used. This is generally computed by BTE_wordSchemeSize (), but can be determined by other means. The scheme is one of 0, no encoding, just return w, 1, encode using 01 = 0, 10 = 10, 11 = 11 2, encode using 01 = 10, 10 = 0, 11 = 11 3, encode using 01 = 10, 10 = 11, 11 = 0 Why is there an encoding scheme The node of the binary encoding is a 2 bit number, indicating whether the left/right neighors are non-mpty. However, to get to a node on of the left or right neighbors must be non-empty. Therefore there are really only 3 states, i.e. only the states 01, 10 and 11 must be represented, 00, being impossible. These three states can be represented by the following bit strings 0 10 11 Without resorting to statistical encoding methods one can pick the the state occuring most of the time to be represented by the symbol with only 1 bit, i.e. 0. Of course, to properly decode the encoded word, one needs the symbol. The user is free to carry the which encoding is to be used by any means he wishes. An extreme example would be to use a fixed scheme for all the symbols. One might compute the size of a collection of symbols using all each scheme, then pick the one that gives the smallest size.

Here is the call graph for this function:

unsigned int BTE_wordPattern (  unsigned int  w  )

Prepares a pattern word which includes all but the lowest level of the binary tree. Parameters: w  The word to encode Returns: The pattern word A 32 bit word express as a binary tree takes a maximum of 63 bits to encode. This tree looks like +---------- x ----------+ word = 1 bit | | +---- x ----+ +---- x ----+ half = 2 bits | | | | +- x -+ +- x -+ +- x -+ +- x -+ byte = 4 bits | | | | | | | | x x x x x x x x nibble = 8 bits / \ / \ / \ / \ / \ / \ / \ / \ x x x x x x x x x x x x x x x x 2 bit = 16 bits ab cd ef gh ij kl mn op qr st uv wx yz AB CD EF 1 bit = 32 bits -- 63 bits This pattern word is arranged by levels from the highest levels in the most significant bits to the lowest levels. Note that the lowest level of the tree is original 32 bit word. Here is an example of tree for w = 0x00011000 1 L0 | 1--------------+----------------1 L1 | | 0-------+-------1 1-------+-------0 L2 | | | | 0---+---0 0---+---1 1---+---0 0---+---0 L3 | | | | | | | | 0-+-0 0-+-0 0-+-0 0-+-1 0-+-1 0-+-0 0-+-0 0-+-0 L4 00 00 00 00 00 00 00 01 00 01 00 00 00 00 00 00 L5 The levels are l0 1 L1 1 1 L2 01 10 L3 0001 0100 L4 00000001 01000000 L5 0000000000000001 0001000000000000 Which, ignoring the lowest level, l5, is the pattern. 0 1 11 0110 00010100 0000000101000000 = 0x76180140 Note, by convention, the highest level of the tree is ignored, so that only the upper 30 bits are used. This is beccause the upper bit only indicates whether the word is 0 or non-zero, something the user can easily determine.

unsigned int BTE_wordSchemeSize (  unsigned int  w, unsigned int  pattern )

Computes the optimal encoding scheme and size using of the 4 possible encoding schemes. Returns: A packed word containing the optimal encoding scheme and its size in bits. The upper 16 bits are the scheme number and the lower 16 bits is the size in bits. Parameters: w  The original word (the lowest level of the tree pattern  The pattern word (the higher levels of the tree The encoding size of using each of the 4 possible encoding schemes is found. The smallest size and its corresponding scheme identifier are returned. The scheme identifiers are 0: Just use the original 32 bit number 1: Use the scheme that assignes the 01 pattern the value 0 2: Use the scheme that assignes the 10 pattern the value 0 3: Use the scheme that assignes the 11 pattern the value 0

Here is the call graph for this function:

unsigned int BTE_wordSize (  unsigned int  w, unsigned int  pattern, unsigned int  scheme )

Computes the size using of the specified encoding schemes. Returns: A packed word containing the encoding scheme and its size in bits. The upper 16 bits are the scheme number and the lower 16 bits is the size in bits. Parameters: w  The original word (the lowest level of the tree pattern  The pattern word (the higher levels of the tree scheme  The encoding scheme to use The schems are 0: Just use the original 32 bit number 1: Use the scheme that assignes the 01 pattern the value 0 2: Use the scheme that assignes the 10 pattern the value 0 3: Use the scheme that assignes the 11 pattern the value 0

Here is the call graph for this function:

unsigned int BTE_wordSizes (  unsigned int  w, unsigned int  pattern )

Computes the bit size of the encoded word using each of the 4 possible encoding schemes. Returns: The 4 sizes packed a byte each into a 32-bit word with scheme 0 packed into the least signficant byte, scheme 1 into the next least signficant byte, etc. Parameters: w  The original word (the lowest level of the tree pattern  The pattern word (the higher levels of the tree The encoding size of using each of the 4 possible encoding schemes is found. The sizes are packed into the 32-bit return value, a byte/size with scheme 0 in the least significant byte. The scheme identifiers are 0: Use the original 32-bit number (implies low byte = 32) 1: Use the scheme that assigns the 01 pattern the value 0 2: Use the scheme that assigns the 10 pattern the value 0 3: Use the scheme that assigns the 11 pattern the value 0

Here is the call graph for this function:

unsigned int encode (  unsigned int  e, unsigned int  w, unsigned int  p1, unsigned int  p3 )  [static]

Encodes the input word w into the output word e. Parameters: e  The current encoded word w  The new set of 32 bits to add p1  The pattern to associate with the encoding pattern 0 p3  The pattern to associate with the encoding pattern 3 The routine encodes 2 bits at a time, extracting the 2 bits from the 2 most significant bits of the input word w. These 2 bits are compared to p1. If they are equal, a single bit, 0, is loaded into the LSB of the output word and the output word is shifted left 1 bit. If these 2 are equal to p3, an encoding pattern of 2 bits is shifted into the LSB of the output word. If the pattern is 0, no bits are inserted. Finally if the pattern is not 0, p1, or p3, the pattern 10 is inserted.

---