FreeCalypso > hg > fc-tourmaline
view src/gpf/ccd/bitfun.c @ 301:4bb5772a05a3
AT%SPVER: new command for setting custom speech version lists
The speech version list in the Bearer Capability IE tells the network
which speech codecs are supported by the MS, and in which order of
preference. The standard behaviour is to list all codecs that are
supported by the hw+fw platform, and the standard preference order
is newer over older, FR over HR. But sometimes it is desirable
(for network testing) to artificially restrict which codecs the test MS
will declare as supported, and/or to list them in some peculiar
non-standard order of preference. Add a new private AT command,
AT%SPVER, allowing the user to set and clear custom speech version
lists for the Bearer Capability IE composer in CC.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sun, 21 May 2023 21:43:10 +0000 |
parents | 4e78acac3d88 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : | Modul : bitfun.c +----------------------------------------------------------------------------- | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose : Definition of constants, types and global variables and bit | stream manipulation functions for CCD +----------------------------------------------------------------------------- */ #define __BITFUN_C__ #ifdef DEBUG_CCD #include <stdio.h> #endif #include "typedefs.h" #include "header.h" #include "string.h" #include "ccd_globs.h" #include "bitfun.h" #include "ccd.h" EXTERN int abs(int); #ifndef RUN_FLASH /* * For each bitlength between 0 and 32 this table contains the * valid masks for right-justificated values */ const ULONG ccd_bitfun_mask[] = { 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff }; /* * Table of one-bit values (2^X) */ const UBYTE ccd_bitfun_shift[] = { 128, 64, 32, 16, 8, 4, 2, 1 }; #else extern const ULONG ccd_bitfun_mask[]; extern const UBYTE ccd_bitfun_shift[]; #endif /* * maschine-dependent implementation * define M_INTEL or M_MOTOROLA dependend on the target system */ #ifdef M_INTEL #define MSB_POS 1 #define LSB_POS 0 #define MSW_POS 2 #define LSW_POS 0 #else #ifdef M_MOTOROLA #define MSB_POS 0 #define LSB_POS 1 #define MSW_POS 0 #define LSW_POS 2 #endif #endif typedef union { /* Conversion structure */ UBYTE c[2]; /* 2 bytes <-> USHORT */ USHORT s; } t_conv16; typedef union { /* Conversion structure */ UBYTE c[4]; /* 4 Byte <-> ULONG */ ULONG l; } t_conv32; #ifndef RUN_FLASH #ifdef DEBUG_CCD /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : ccd_BITIMAGE | +--------------------------------------------------------------------+ PURPOSE : convert a ULONG value to a ascii-bitstring with the length len. */ char *ccd_BITIMAGE (ULONG val, ULONG len, T_CCD_Globs *globs) { int i; for (i=31; i >= 0; i--) { globs->buf [i] = (char)(val & 1)+'0'; val >>= 1; } globs->buf [32] = '\0'; return globs->buf+(32-len); } #endif #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : fmemcpy | +--------------------------------------------------------------------+ PURPOSE : copies len bytes from source to dest for FAR addresses. */ void fmemcpy (UBYTE * d, UBYTE *s, USHORT len) { while (len--) *d++ = *s++; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_writeBitChunk | +--------------------------------------------------------------------+ PURPOSE : The global pointer globs->pstruct+globs->pstructOffs references a buffer struct containing the len, offset and content of a bitbuffer. This funtions copies the bits to the bitstream buffer at the actual position. */ void bf_writeBitChunk (ULONG len, T_CCD_Globs *globs) { ULONG offs; ULONG bytesToCopy=0; signed char theShift; U8 *MsgStruct = (U8*)(globs->pstruct + globs->pstructOffs); U8 ByteOffs = globs->byteoffs; U8 *MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); /* * Read the length of the buffer (the l_buf component) and * compare it with the parameter given. */ len = MINIMUM (len, *((USHORT *)MsgStruct)); if (!len) return; bytesToCopy = (ULONG) ((len + ByteOffs + 7)>> 3); offs = (ULONG)(*(USHORT *)(MsgStruct + 2)); theShift = (signed char) (offs - ByteOffs); #ifdef DEBUG_CCD TRACE_CCD (globs, "reading 2+2+%ld bytes from struct %08X, writing %d bits at byte %d.%d", bytesToCopy, MsgStruct + 4, len, globs->bytepos, globs->byteoffs); #endif if ((abs(theShift) & 7) EQ 0) { MsgStruct += (4+(offs>>3)); /* * the bits in the Buffer are in the right position * -> quick memcopy. */ /* * write the first byte, clean the leading bits */ *MsgBuf |= (*MsgStruct & (UBYTE) ccd_bitfun_mask[8 - (offs&7)]); /* * copy the remaining bytes */ if (bytesToCopy) { memcpy ((UBYTE *) &MsgBuf[1], MsgStruct + 1, (size_t)bytesToCopy-1); } if ((ByteOffs+len)&7) { MsgBuf[bytesToCopy-1] &= ~ccd_bitfun_mask[8-((ByteOffs+len)&7)]; } } else { t_conv16 conv; /* * shift every single byte */ MsgStruct += (4+(offs>>3)); if (bytesToCopy > 1) { --bytesToCopy; } if (theShift > 0) { /* * shift all bytes leftwise */ /* * the first byte must be masked */ theShift &= 7; conv.c[MSB_POS] = *MsgStruct++ & (UBYTE) ccd_bitfun_mask[8-(offs&7)]; conv.c[LSB_POS] = *MsgStruct; conv.s <<= theShift; *MsgBuf++ |= conv.c[MSB_POS]; *MsgBuf = conv.c[LSB_POS]; --bytesToCopy; while (bytesToCopy) { conv.c[MSB_POS] = *MsgStruct++; conv.c[LSB_POS] = *MsgStruct; conv.s <<= theShift; *MsgBuf++ |= conv.c[MSB_POS]; *MsgBuf = conv.c[LSB_POS]; --bytesToCopy; } conv.c[MSB_POS] = *MsgStruct++; conv.c[LSB_POS] = *MsgStruct; conv.s <<= theShift; *MsgBuf |= conv.c[MSB_POS]; if ((ByteOffs+len)&7) { *MsgBuf &= ~ccd_bitfun_mask[8-((ByteOffs+len)&7)]; } } else { /* * shift all bytes rightwise */ /* * the first byte must be masked, we dont want to store the * leading garbage before the valid bits */ theShift = (-theShift & 7); conv.c[MSB_POS] = *MsgStruct++ & (UBYTE) ccd_bitfun_mask[8-(offs&7)]; conv.c[LSB_POS] = *MsgStruct; conv.s >>= theShift; *MsgBuf++ |= conv.c[MSB_POS]; *MsgBuf = conv.c[LSB_POS]; --bytesToCopy; while (bytesToCopy) { conv.c[MSB_POS] = *MsgStruct++; conv.c[LSB_POS] = *MsgStruct; conv.s >>= theShift; *MsgBuf++ |= conv.c[MSB_POS]; *MsgBuf = conv.c[LSB_POS]; --bytesToCopy; } conv.c[MSB_POS] = *MsgStruct++; conv.c[LSB_POS] = *MsgStruct; conv.s >>= theShift; *MsgBuf |= conv.c[MSB_POS]; if ((ByteOffs+len)&7) { *MsgBuf &= ~ccd_bitfun_mask[8-((ByteOffs+len)&7)]; } } } bf_incBitpos (len, globs); globs->pstructOffs = MsgStruct - globs->pstruct - 1; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_writeBits | +--------------------------------------------------------------------+ PURPOSE : The pointer globs->pstruct + globs->pstructOffs refers to a var in the message C-structure. This function writes the numeric content of the var into the bit stream referenced by globs->bitbuf. According to the required lenght (len) the type of the var is interpreted as BYTE/SHORT or LONG. */ void bf_writeBits (ULONG len, T_CCD_Globs *globs) { /* * Bit field is given by its lenght, offset bit and buffer. */ if (len > 32) { bf_writeBitChunk (len, globs); return; } else { UBYTE *MsgStruct = (UBYTE*)(globs->pstruct + globs->pstructOffs); U8 ByteOffs = globs->byteoffs; UBYTE *MsgBuf = (UBYTE*)(globs->bitbuf + globs->bytepos); U32 wBits; wBits = len + ByteOffs; if (len > 24) { t_conv32 conv32; UBYTE FirstByte; conv32.l = *((ULONG *) MsgStruct); conv32.l &= (ULONG) ccd_bitfun_mask[len]; conv32.l <<= (32-len); FirstByte = conv32.c[MSW_POS + MSB_POS]; FirstByte >>= ByteOffs; FirstByte &= (UBYTE) ccd_bitfun_mask[8-ByteOffs]; *MsgBuf++ |= FirstByte; conv32.l <<= (8-ByteOffs); *MsgBuf++ = conv32.c[MSW_POS + MSB_POS] ; *MsgBuf++ = conv32.c[MSW_POS + LSB_POS] ; *MsgBuf++ = conv32.c[LSW_POS + MSB_POS] ; if (wBits > 32) *MsgBuf = conv32.c[LSW_POS + LSB_POS] ; } /* * Bit field given in a C variable is shorter than a USHORT. */ #ifdef DEBUG_CCD TRACE_CCD (globs, "write %d bits at byte %d.%d", len, globs->bytepos, ByteOffs); #endif if (len > 8) { t_conv32 conv; conv.l = (len > 16) ? *(ULONG *) MsgStruct : (ULONG) * (USHORT *) MsgStruct; conv.l &= ccd_bitfun_mask[len]; #ifdef DEBUG_CCD TRACE_CCD (globs, " (.%s)", ccd_BITIMAGE (conv.l, len, globs)); #endif conv.l <<= (32 - wBits); *MsgBuf |= conv.c[MSW_POS + MSB_POS]; MsgBuf[1] |= conv.c[MSW_POS + LSB_POS]; if (wBits > 16) { MsgBuf[2] |= conv.c[LSW_POS + MSB_POS]; if (wBits > 24) { MsgBuf[3] |= conv.c[LSW_POS + LSB_POS]; } } } else { t_conv16 conv; conv.s = (USHORT) (*MsgStruct); conv.s &= (USHORT) ccd_bitfun_mask[len]; #ifdef DEBUG_CCD TRACE_CCD (globs, " (.%s)", ccd_BITIMAGE ((ULONG) conv.s, len, globs)); #endif conv.s <<= (16 - wBits); *MsgBuf |= conv.c[MSB_POS]; if (wBits > 8) { MsgBuf[1] |= conv.c[LSB_POS]; } } bf_incBitpos (len, globs); } } #endif /* !RUN_FLASH */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_writeBitStr_PER | +--------------------------------------------------------------------+ PURPOSE : The pointer globs->pstruct + globs->pstructOffs refers to a var in the message C-structure. This function writes the numeric content of the var into the bit stream referenced by globs->bitbuf. */ void bf_writeBitStr_PER (USHORT len, T_CCD_Globs *globs) { USHORT bytesToCopy; t_conv16 Last2Bytes; U8 *MsgStruct = (U8*)(globs->pstruct + globs->pstructOffs); U8 ByteOffs = globs->byteoffs; U8 *MsgBuf; MsgBuf = (U8*)(globs->bitbuf + globs->bytepos + ((ByteOffs + len) >> 3)); /* * Store the data for a later compensation of buffer overwritting. * bytepos is always greater than 1, since the first byte with bytepos=0 * is dedicated to message identifier. */ Last2Bytes.c[MSB_POS] = MsgBuf[0]; Last2Bytes.c[LSB_POS] = MsgBuf[1]; MsgBuf -= (ByteOffs + len) >> 3; bytesToCopy = (len+7) >> 3; #ifdef DEBUG_CCD TRACE_CCD (globs, "copying %d byte(s) from struct 0x%08X, writing %d bits at byte %d.%d", bytesToCopy, MsgStruct, len, globs->bytepos, globs->byteoffs); { int i=0; int j=0; char s[64], c[4]; int leftBytes = bytesToCopy; TRACE_CCD (globs, " Bit string to be encoded:"); s[0] = '\0'; for (i = 0; leftBytes > 0 ; i++) { for (j = 0; (j < 16 && (leftBytes-- > 0)) ; j++) { sprintf(c, " %02x", *(MsgStruct+(16*i)+j)); strcat (s, c); } TRACE_CCD (globs, "%s", s); s[0] = '\0'; } } #endif /* * The bits will be appended to the bit buffer at byte boundary. */ if (ByteOffs EQ 0) { /* * CCD assumes that the bits to be copied are left adjusted * int their place in the C-structure. */ memcpy ((UBYTE *) MsgBuf, MsgStruct, (size_t)bytesToCopy); MsgBuf += bytesToCopy; } else { t_conv16 conv; /* * Write byte for byte while compensating non-zero value of globs->byteoffs. */ while (bytesToCopy--) { conv.c[MSB_POS] = *MsgStruct++; conv.c[LSB_POS] = *MsgStruct; conv.s >>= ByteOffs; conv.s &= (USHORT) ccd_bitfun_mask[16-ByteOffs]; *MsgBuf++ |= conv.c[MSB_POS]; *MsgBuf |= conv.c[LSB_POS]; } } bf_incBitpos (len, globs); /* * Undo overwriting of bits which do not belong to the bit string. */ MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); MsgBuf[0] &= ~ccd_bitfun_mask[8-globs->byteoffs]; Last2Bytes.c[MSB_POS] &= (UBYTE) ccd_bitfun_mask[8-globs->byteoffs]; MsgBuf[0] |= Last2Bytes.c[MSB_POS]; MsgBuf[1] = Last2Bytes.c[LSB_POS]; } #endif /* !RUN_INT_RAM */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_writePadBits | +--------------------------------------------------------------------+ PURPOSE : The global pointer globs->bitbuf points to the bit stream buffer. This function adds 0-7 zero bits to the bit stream from the point globs->byteoffs refer to. */ void bf_writePadBits (T_CCD_Globs *globs) { if (globs->byteoffs NEQ 0) { globs->bitbuf[globs->bytepos] &= (UBYTE) ~ccd_bitfun_mask[8-globs->byteoffs]; #ifdef DEBUG_CCD TRACE_CCD (globs, "writing %d pad bit(s) at byte %d.%d", 8-globs->byteoffs, globs->bytepos, globs->byteoffs); #endif bf_incBitpos (8-globs->byteoffs, globs); } } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_readBit | +--------------------------------------------------------------------+ PURPOSE : The global pointer globs->bitbuf points to the bit stream buffer. This function reads the bit to which the global positioning pointers are pointing to. */ BOOL bf_readBit (T_CCD_Globs *globs) { UBYTE ret; ret = globs->bitbuf[globs->bytepos] & ccd_bitfun_shift[globs->byteoffs]; bf_incBitpos (1, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "reading 1 bit (%d) at byte %d.%d", (ret>0)?1:0, globs->bytepos, globs->byteoffs); #endif return (ret > 0); } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_writeBit | +--------------------------------------------------------------------+ PURPOSE : The global pointer globs->bitbuf points to the bit stream buffer. This function writes a given value into the bit to which the global positioning pointers are pointing to. */ void bf_writeBit (BOOL Bit, T_CCD_Globs *globs) { globs->bitbuf[globs->bytepos] = Bit ? (globs->bitbuf[globs->bytepos] | ccd_bitfun_shift[globs->byteoffs]) : (globs->bitbuf[globs->bytepos] & ~ccd_bitfun_shift[globs->byteoffs]); #ifdef DEBUG_CCD TRACE_CCD (globs, "writing 1 bit (%d) at byte %d.%d", Bit, globs->bytepos, globs->byteoffs); #endif bf_incBitpos (1, globs); } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_rShift8Bit | +--------------------------------------------------------------------+ PURPOSE : shifts a bitfield in the bitstream by 8 bits rightwise. The function is used only for octet aligned types. Hence offset is not involved in calculation. */ void bf_rShift8Bit ( USHORT srcBitPos, USHORT bitLen, T_CCD_Globs *globs ) { register UBYTE bytesToCopy; USHORT bytepos; /* * destination > source -> start with last byte */ bytepos = srcBitPos >> 3; bytesToCopy = bitLen >> 3; #ifdef DEBUG_CCD TRACE_CCD (globs, "shifting %d bits rightwise for 8 bits", bitLen); #endif while (bytesToCopy) { globs->bitbuf[bytepos+bytesToCopy] = globs->bitbuf[bytepos+bytesToCopy-1]; bytesToCopy--; } globs->bitbuf[bytepos] = 0; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_readBitChunk | +--------------------------------------------------------------------+ PURPOSE : reads (len) Bits from the Bitsream (globs->bitbuf) and stores them to the T_MSGBUF struct, containig the len the offset and a bitbuffer. */ void bf_readBitChunk (ULONG len, T_CCD_Globs *globs) { ULONG bytesToCopy; U8 *MsgStruct = (U8*)(globs->pstruct + globs->pstructOffs); U8 ByteOffs = globs->byteoffs; U8 *MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); *(U16*) (MsgStruct) = (U16) len; MsgStruct += 2; *(U16*) (MsgStruct) = (U16)ByteOffs; MsgStruct += 2; bytesToCopy = (ULONG) ((len >> 3)+(len&7?1:0)+(ByteOffs?1:0)); #ifdef DEBUG_CCD TRACE_CCD (globs, "reading %ld bits from byte %d.%d, writing 2+2+%ld bytes to struct %08X", len, globs->bytepos, globs->byteoffs, bytesToCopy, MsgStruct); #endif memcpy ((UBYTE *) MsgStruct, MsgBuf, (size_t)bytesToCopy); #if 0 #ifdef DEBUG_CCD { int i; for (i=0; i<bytesToCopy; i++) { TRACE_CCD (globs, "buf[%d] = 0x%02x", i, MsgStruct[i]); } } #endif #endif /* * cutoff the leading and trailing bits wich are obsolete */ *MsgStruct &= ccd_bitfun_mask [8-ByteOffs]; if ((len+ByteOffs)&7) { MsgStruct += (bytesToCopy-1); *MsgStruct &= ~ccd_bitfun_mask [8-((len+ByteOffs)&7)]; } #if 0 #ifdef DEBUG_CCD { int i; for (i=0; i<bytesToCopy; i++) { TRACE_CCD (globs, "buf[%d] = 0x%02x", i, MsgStruct[i]); } } #endif #endif bf_incBitpos (len, globs); } #endif /* !RUN_FLASH */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_readBitStr_PER | +--------------------------------------------------------------------+ PURPOSE : The pointer globs->pstruct + globs->pstructOffs refers to a var in the message C-structure. This function reads len bits from the bit stream (globs->bitbuf) and stores them left adjusted to the bytes in the message C-structure. */ void bf_readBitStr_PER (USHORT len, T_CCD_Globs *globs) { USHORT bytesToCopy; t_conv16 Last2Bytes; U8 *MsgStruct = (U8*)(globs->pstruct + globs->pstructOffs); U8 *MsgStructEnd = (U8*)(globs->pstruct + globs->pstructOffs + (len >> 3)); U8 ByteOffs = globs->byteoffs; U8 *MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); bytesToCopy = (len+7) >> 3; /* * Store the data for a later compensation of buffer overwritting. */ Last2Bytes.c[MSB_POS] = MsgStructEnd[0]; Last2Bytes.c[LSB_POS] = MsgStructEnd[1]; /* * The bits will be read from the bit buffer at byte boundary. */ if (ByteOffs EQ 0) { #ifdef DEBUG_CCD TRACE_CCD (globs, "reading %d bits from byte %d.%d, copying %d bytes to struct at 0x%08X", len, globs->bytepos, globs->byteoffs, bytesToCopy, MsgStruct); #endif /* * CCD assumes that the caller function needs the bit string to be * left adjusted in the C-structure. */ memcpy ((UBYTE *) MsgStruct,//(globs->pstruct + globs->pstructOffs), MsgBuf, (size_t)bytesToCopy); } else { t_conv16 conv; /* * Read byte for byte while compensating the non-zero globs->byteoffs. */ while (bytesToCopy--) { conv.c[MSB_POS] = *MsgBuf++; conv.c[LSB_POS] = *MsgBuf; conv.s <<= ByteOffs; conv.s &= (USHORT) ~ccd_bitfun_mask[8-(len&7)]; *MsgStruct++ = conv.c[MSB_POS]; *MsgStruct = conv.c[LSB_POS]; } } /* * Undo overwriting in C-Structure. This is specially necessary * for later reading of valid flags for optional elments. */ MsgStructEnd[0] &= (UBYTE) ~ccd_bitfun_mask[8-(len&7)]; Last2Bytes.c[MSB_POS] &= (UBYTE) ccd_bitfun_mask[8-(len&7)]; MsgStructEnd[0] |= Last2Bytes.c[MSB_POS]; MsgStructEnd[1] = Last2Bytes.c[LSB_POS]; #ifdef DEBUG_CCD { int i=0; int j=0; char s[64], c[4]; int leftBytes = (len+7) >> 3;; MsgStruct = (U8*)(globs->pstruct + globs->pstructOffs); TRACE_CCD (globs, " Decoded bit string:"); s[0] = '\0'; for (i = 0; leftBytes > 0 ; i++) { for (j = 0; (j < 16 && (leftBytes-- > 0)) ; j++) { sprintf(c, " %02x", *(MsgStruct+(16*i)+j)); strcat (s, c); } TRACE_CCD (globs, "%s", s); s[0] = '\0'; } } #endif globs->pstructOffs += ((len+7) >> 3); bf_incBitpos (len, globs); } #endif /* !RUN_INT_RAM */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_readBits | +--------------------------------------------------------------------+ PURPOSE : reads (len) Bits from the Bitsream (globs->bitbuf) and stores them typed (dependent on the length) to vars in the C-struct referenced by the global var globs->pstruct+globs->pstructOff. */ void bf_readBits (ULONG len, T_CCD_Globs *globs) { /* * Bit field is given by its lenght, offset bit and buffer. */ if (len > 32) { bf_readBitChunk (len, globs); return; } else { t_conv16 conv16; t_conv32 conv32; U8 *MsgStruct = (U8*)(globs->pstruct + globs->pstructOffs); U8 ByteOffs = globs->byteoffs; U8 *MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); #ifdef DEBUG_CCD TRACE_CCD (globs, "reading %d bits form byte %d.%d,", len, globs->bytepos, globs->byteoffs); #endif /* * Bit field is given in a C variable shorter than a USHORT. */ if (len <= 8) { if (globs->lastbytepos16 != globs->bytepos) { conv16.c[MSB_POS] = *MsgBuf++; conv16.c[LSB_POS] = *MsgBuf; globs->lastbytepos16 = globs->bytepos; globs->last16Bit = conv16.s; } else conv16.s = globs->last16Bit; conv16.s >>= (16 - (ByteOffs + len)); conv16.s &= (USHORT) ccd_bitfun_mask[len]; *MsgStruct = (UBYTE) conv16.s; #ifdef DEBUG_CCD TRACE_CCD (globs, "writing 1 bytes (%0X) to struct %08X", *MsgStruct, MsgStruct); #endif } else if (len + ByteOffs <= 32) { if (globs->lastbytepos32 != globs->bytepos) { conv32.c[MSW_POS + MSB_POS] = *MsgBuf++; conv32.c[MSW_POS + LSB_POS] = *MsgBuf++; conv32.c[LSW_POS + MSB_POS] = *MsgBuf++; conv32.c[LSW_POS + LSB_POS] = *MsgBuf; globs->lastbytepos32 = globs->bytepos; globs->last32Bit = conv32.l; } else conv32.l = globs->last32Bit; conv32.l >>= (32 - (ByteOffs + len)); conv32.l &= ccd_bitfun_mask[len]; if (len > 16) { *((ULONG *) MsgStruct) = conv32.l; #ifdef DEBUG_CCD TRACE_CCD (globs, "writing 4 bytes (%08X) to struct %08X", conv32.l, MsgStruct); #endif } else { *((USHORT *) MsgStruct) = (USHORT) conv32.l; #ifdef DEBUG_CCD TRACE_CCD (globs, "writing 2 bytes (%04X) to struct %08X", (USHORT) conv32.l, MsgStruct); #endif } } else { UBYTE FirstByte; FirstByte = *MsgBuf++; FirstByte <<= ByteOffs; FirstByte &= (UBYTE) ~ccd_bitfun_mask[ByteOffs]; if (globs->lastbytepos32 != globs->bytepos) { conv32.c[MSW_POS + MSB_POS] = *MsgBuf++; conv32.c[MSW_POS + LSB_POS] = *MsgBuf++; conv32.c[LSW_POS + MSB_POS] = *MsgBuf++; conv32.c[LSW_POS + LSB_POS] = *MsgBuf; globs->lastbytepos32 = globs->bytepos; globs->last32Bit = conv32.l; } else { conv32.l = globs->last32Bit; } if (!ByteOffs) { conv32.l >>= 8; } else { conv32.l >>= (8-ByteOffs); } conv32.c[MSW_POS + MSB_POS] &= (UBYTE) ccd_bitfun_mask[ByteOffs]; conv32.c[MSW_POS + MSB_POS] |= FirstByte; conv32.l >>= (32-len); conv32.l &= (ULONG) ccd_bitfun_mask[len]; *((ULONG *) MsgStruct) = conv32.l; #ifdef DEBUG_CCD TRACE_CCD ( globs, "writing 4 bytes (%08X) to struct %08X", conv32.l, MsgStruct); #endif } bf_incBitpos (len, globs); return; } } #endif /* !RUN_FLASH */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_writeVal | +--------------------------------------------------------------------+ PURPOSE : writes value into the next (bSize) bits of the air message buffer(globs->bitbuf). This function does not use the data in the C-structure. This is done by the caller function while calculating value. */ void bf_writeVal (ULONG value, ULONG bSize, T_CCD_Globs *globs) { ULONG BitSum; U8 *MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); U8 ByteOffs = globs->byteoffs; #ifdef DEBUG_CCD TRACE_CCD (globs, "writeVal %d bits at byte %d.%d", bSize, globs->bytepos, ByteOffs); #endif /* * value will be written into a temporary buffer. This buffer will * then be prepared for an ORing with the bit buffer of air message. * BitSum is helpful to find out the right size for temporary buffer. */ BitSum = bSize + (ULONG)ByteOffs; /* * Write in 1 to 8 bits (bSize is 1-8). */ if (BitSum <= 8) { UBYTE TmpBuf; #ifdef DEBUG_CCD TRACE_CCD (globs, " (.%s)", ccd_BITIMAGE ((ULONG)(value & ccd_bitfun_mask[bSize]), bSize, globs)); #endif TmpBuf = (UBYTE) value; TmpBuf &= (UBYTE) ccd_bitfun_mask[bSize]; TmpBuf <<= (8 - BitSum); *MsgBuf |= TmpBuf; } else { /* * Write in 9 to 16 bits (bSize is 9-16). */ if (BitSum <= 16) { t_conv16 conv; conv.s = (USHORT) value; conv.s &= (USHORT) ccd_bitfun_mask[bSize]; #ifdef DEBUG_CCD TRACE_CCD (globs, " (.%s)", ccd_BITIMAGE ((ULONG) conv.s, bSize, globs)); #endif conv.s <<= (16 - BitSum); MsgBuf[0] |= conv.c[MSB_POS]; MsgBuf[1] |= conv.c[LSB_POS]; } /* * Write in 17 to 25 bits (bSize is 17-25). */ else if (BitSum <= 32) { t_conv32 conv; conv.l = value; conv.l &= ccd_bitfun_mask[bSize]; #ifdef DEBUG_CCD TRACE_CCD (globs, " (.%s)", ccd_BITIMAGE ((ULONG)conv.l, bSize, globs)); #endif conv.l <<= (32 - BitSum); MsgBuf[0] |= conv.c[MSW_POS + MSB_POS]; MsgBuf[1] |= conv.c[MSW_POS + LSB_POS]; MsgBuf[2] |= conv.c[LSW_POS + MSB_POS]; if (BitSum > 24) { MsgBuf[3] |= conv.c[LSW_POS + LSB_POS]; } } /* * Write in 25 to 32 bits (bSize is 25-32). */ else if ( BitSum < 40) { UBYTE FirstByte; t_conv32 conv; conv.l = value; conv.l <<= (32 - bSize); FirstByte = conv.c[MSW_POS + MSB_POS]; FirstByte >>= ByteOffs; FirstByte &= (UBYTE) ccd_bitfun_mask[8-ByteOffs]; MsgBuf[0] |= FirstByte; conv.l <<= (8 - ByteOffs); MsgBuf[1] |= conv.c[MSW_POS + MSB_POS]; MsgBuf[2] |= conv.c[MSW_POS + LSB_POS]; MsgBuf[3] |= conv.c[LSW_POS + MSB_POS]; MsgBuf[4] |= conv.c[LSW_POS + LSB_POS]; #ifdef DEBUG_CCD conv.l &= (ULONG) ~ccd_bitfun_mask[24-ByteOffs]; TRACE_CCD (globs, " (.%s)", ccd_BITIMAGE ((ULONG) FirstByte, (ULONG)(8-ByteOffs), globs)); TRACE_CCD (globs, " (.%s)", ccd_BITIMAGE (conv.l, (ULONG)(24-ByteOffs), globs)); #endif } /* * This case is currently not supported. * Integer values are written to and read from up to 32 bits. */ else { return; } } bf_incBitpos (bSize, globs); } #endif /* !RUN_INT_RAM */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_getBits | +--------------------------------------------------------------------+ PURPOSE : reads len Bits from the Bitstream (globs->bitbuf) and stores them in a variable. The caller function can now interpret or process the content of the returned variable. */ ULONG bf_getBits (ULONG len, T_CCD_Globs *globs) { U8 ByteOffs = globs->byteoffs; U8 *MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); #ifdef DEBUG_CCD TRACE_CCD (globs, "reading %ld bits form byte %d.%d,", len, globs->bytepos, globs->byteoffs); #endif /* * Read up to 8 bits from the air message buffer. */ if (len <= 8) { t_conv16 conv16; if (globs->lastbytepos16 != globs->bytepos) { conv16.c[MSB_POS] = *MsgBuf++; conv16.c[LSB_POS] = *MsgBuf; globs->lastbytepos16 = globs->bytepos; globs->last16Bit = conv16.s; } else { conv16.s = globs->last16Bit; } conv16.s >>= (16 - (ByteOffs + len)); conv16.s &= (USHORT) ccd_bitfun_mask[len]; #ifdef DEBUG_CCD TRACE_CCD (globs, "read value: %d", conv16.s); #endif bf_incBitpos (len, globs); return (ULONG) conv16.s; } /* * Read between 8 and 24 bits from the air message buffer. */ else if (len <= 24) { t_conv32 conv32; if (globs->lastbytepos32 != globs->bytepos) { conv32.c[MSW_POS + MSB_POS] = *MsgBuf++; conv32.c[MSW_POS + LSB_POS] = *MsgBuf++; conv32.c[LSW_POS + MSB_POS] = *MsgBuf++; conv32.c[LSW_POS + LSB_POS] = *MsgBuf; globs->lastbytepos32 = globs->bytepos; globs->last32Bit = conv32.l; } else { conv32.l = globs->last32Bit; } conv32.l >>= (32 - (ByteOffs + len)); conv32.l &= ccd_bitfun_mask[len]; #ifdef DEBUG_CCD TRACE_CCD (globs, "read value: %ld", conv32.l); #endif bf_incBitpos (len, globs); return conv32.l; } /* * Read between 24 and 32 bits from the air message buffer. */ else if ( len <= 32) { UBYTE FirstByte; t_conv32 conv; FirstByte = *MsgBuf++; FirstByte <<= ByteOffs; FirstByte &= (UBYTE) ~ccd_bitfun_mask[ByteOffs]; if (globs->lastbytepos32 != globs->bytepos) { conv.c[MSW_POS + MSB_POS] = *MsgBuf++; conv.c[MSW_POS + LSB_POS] = *MsgBuf++; conv.c[LSW_POS + MSB_POS] = *MsgBuf++; conv.c[LSW_POS + LSB_POS] = *MsgBuf; globs->lastbytepos32 = globs->bytepos; globs->last32Bit = conv.l; } else { conv.l = globs->last32Bit; } if (!ByteOffs) { conv.l >>= 8; } else { conv.l >>= (8-ByteOffs); } conv.c[MSW_POS + MSB_POS] &= (UBYTE) ccd_bitfun_mask[ByteOffs]; conv.c[MSW_POS + MSB_POS] |= FirstByte; conv.l >>= (32-len); conv.l &= (ULONG) ccd_bitfun_mask[len]; #ifdef DEBUG_CCD TRACE_CCD (globs, "read value: %ld", conv.l); #endif bf_incBitpos (len, globs); return conv.l; } /* * This case is currently not supported. * Integer values are written to and read from up to 32 bits. */ else { return 0; } } #endif /* !RUN_INT_RAM */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_decodeLongNumber | +--------------------------------------------------------------------+ PURPOSE : reads (len) Bits from the Bitsream (globs->bitbuf) and return this number as a 32 Bit number. The Position of the readpointer of the bitstream is incremented by the len. */ ULONG bf_decodeLongNumber (UBYTE len, T_CCD_Globs *globs) { U32 number; t_conv16 conv16; t_conv32 conv32; U8 ByteOffs = globs->byteoffs; U8 *MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); #ifdef DEBUG_CCD TRACE_CCD (globs, "reading %d bits form byte %d.%d,", len, globs->bytepos, globs->byteoffs); #endif if (len <= 8) { if (globs->lastbytepos16 != globs->bytepos) { conv16.c[MSB_POS] = *MsgBuf++; conv16.c[LSB_POS] = *MsgBuf; globs->lastbytepos16 = globs->bytepos; globs->last16Bit = conv16.s; } else conv16.s = globs->last16Bit; conv16.s >>= (16 - (ByteOffs + len)); conv16.s &= (USHORT) ccd_bitfun_mask[len]; number = (ULONG) conv16.s; } else { if (globs->lastbytepos32 != globs->bytepos) { conv32.c[MSW_POS + MSB_POS] = *MsgBuf++; conv32.c[MSW_POS + LSB_POS] = *MsgBuf++; conv32.c[LSW_POS + MSB_POS] = *MsgBuf++; conv32.c[LSW_POS + LSB_POS] = *MsgBuf; globs->lastbytepos32 = globs->bytepos; globs->last32Bit = conv32.l; } else conv32.l = globs->last32Bit; conv32.l >>= (32 - (ByteOffs + len)); conv32.l &= ccd_bitfun_mask[len]; number = conv32.l; } bf_incBitpos (len, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, " (%08X)", number); #endif return number; } #endif /* !RUN_INT_RAM */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_decodeShortNumber| +--------------------------------------------------------------------+ PURPOSE : reads (len) Bits from the Bitsream (globs->bitbuf) and returns the resulting value as an ULONG. */ ULONG bf_decodeShortNumber (const ULONG len, T_CCD_Globs *globs) { UBYTE *p; t_conv32 conv32; p = globs->bitbuf + globs->bytepos; conv32.c[MSW_POS + MSB_POS] = *p++; conv32.c[MSW_POS + LSB_POS] = *p++; conv32.c[LSW_POS + MSB_POS] = *p++; conv32.c[LSW_POS + LSB_POS] = *p; conv32.l >>= (32 - (globs->byteoffs + len)); conv32.l &= ccd_bitfun_mask[len]; bf_incBitpos (len, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "reading %d bits as LONG (%d) at byte %d.%d", len, (ULONG) conv32.l, globs->bytepos, globs->byteoffs); #endif return (ULONG) conv32.l; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_decodeByteNumber | +--------------------------------------------------------------------+ PURPOSE : reads (len) Bits from the Bitsream (globs->bitbuf) and returns the resulting value as an UBYTE. */ UBYTE bf_decodeByteNumber (const ULONG len, T_CCD_Globs *globs) { UBYTE *p; t_conv16 conv16; p = globs->bitbuf + globs->bytepos; conv16.c[MSB_POS] = *p++; conv16.c[LSB_POS] = *p; conv16.s >>= (16 - (globs->byteoffs + len)); conv16.s &= (USHORT) ccd_bitfun_mask[len]; bf_incBitpos (len, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "reading %d bits as BYTE (%d) at byte %d.%d", len, (UBYTE) conv16.s, globs->bytepos, globs->byteoffs); #endif return (UBYTE) conv16.s; } #endif /* !RUN_FLASH */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_codeShortNumber | +--------------------------------------------------------------------+ PURPOSE : Converts the value (val) into a MSB/LSB-Bitstring and writes it to the aktual position into the bitstream globs->bitbuf. The maximum value of (len) is 16. If the value of (val) is greater then (2^len)-1 it will be truncated. */ void bf_codeShortNumber (UBYTE len, USHORT val, T_CCD_Globs *globs) { UBYTE *p; t_conv32 conv32; #ifdef DEBUG_CCD TRACE_CCD (globs, "codeShortNumber: writing %d bits (.%s) at byte %d.%d", len, ccd_BITIMAGE (val, (ULONG) len, globs), globs->bytepos, globs->byteoffs); #endif p = globs->bitbuf + globs->bytepos; conv32.l = (ULONG) val; conv32.l <<= (32 - len - globs->byteoffs); *p++ |= conv32.c[MSW_POS + MSB_POS]; *p = conv32.c[MSW_POS + LSB_POS]; if ((globs->byteoffs + len) > 16) *++p = conv32.c[LSW_POS + MSB_POS]; bf_incBitpos (len, globs); } #endif /* !RUN_INT_RAM */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_recodeShortNumber| +--------------------------------------------------------------------+ PURPOSE: Converts the value (val) into a MSB/LSB-Bitstring and writes it at the position (pos) into the bitstream globs->bitbuf. The rest of the bitstream and the actual position will not changed. The maximum value of (len) is 16. If the value of (val) is greater then (2^len)-1 it will be truncated. */ void bf_recodeShortNumber (USHORT pos, UBYTE len, USHORT val, T_CCD_Globs *globs) { UBYTE *p; USHORT oldbitpos; t_conv32 conv32; USHORT wBits; oldbitpos = globs->bitpos; bf_setBitpos (pos, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "bf_recodeShortNumber:rewriting %d bits (.%s) at byte %d.%d", len, ccd_BITIMAGE ((ULONG) val, len, globs), globs->bytepos, globs->byteoffs); #endif wBits = len + globs->byteoffs; p = globs->bitbuf + globs->bytepos; conv32.l = (ULONG) val; conv32.l <<= (32 - wBits); /* * Since the bits to write are cleared (memclr) in the bitstream, * it is ok to perform an OR operation on them. */ *p++ |= conv32.c[MSW_POS + MSB_POS]; if (wBits > 8) { *p++ |= conv32.c[MSW_POS + LSB_POS]; if (wBits > 16) { *p++ |= conv32.c[LSW_POS + MSB_POS]; if (wBits > 24) *p |= conv32.c[LSW_POS + LSB_POS]; } } bf_setBitpos (oldbitpos, globs); } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_recodeByteNumber | +--------------------------------------------------------------------+ PURPOSE: Converts the value (val) into a MSB/LSB-Bitstring and writes it at the position (pos) into the bitstream globs->bitbuf. The rest of the bitstream and the actual position will not changed. The maximum value of (len) is 8. If the value of (val) is greater then (2^len)-1 it will be truncated. */ void bf_recodeByteNumber (USHORT pos, UBYTE len, UBYTE val, T_CCD_Globs *globs) { UBYTE *p; USHORT oldbitpos; t_conv16 conv16; oldbitpos = globs->bitpos; bf_setBitpos (pos, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "bf_recodeByteNumber:rewriting %d bits (.%s) at byte %d.%d", len, ccd_BITIMAGE ((ULONG) val, len, globs), globs->bytepos, globs->byteoffs); #endif p = globs->bitbuf + globs->bytepos; conv16.s = (USHORT) val; conv16.s <<= (16 - len - globs->byteoffs); /* * if the bits to write are cleared (memclr) in the bitstream * we can perform an OR operation on it */ *p++ |= conv16.c[MSB_POS]; if ((len + globs->byteoffs) > 8) *p |= conv16.c[LSB_POS]; bf_setBitpos (oldbitpos, globs); } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_recodeBit | +--------------------------------------------------------------------+ PURPOSE: Writes the value of (Bit) at the position (pos) into the bitstream globs->bitbuf. The rest of the bitstream and the actual position will not changed. */ void bf_recodeBit (USHORT pos, UBYTE Bit, T_CCD_Globs *globs) { U16 oldbitpos = globs->bitpos;; bf_setBitpos (pos, globs); globs->bitbuf[globs->bytepos] = Bit ? (globs->bitbuf[globs->bytepos] | ccd_bitfun_shift[globs->byteoffs]) : (globs->bitbuf[globs->bytepos] & ~ccd_bitfun_shift[globs->byteoffs]); bf_setBitpos (oldbitpos, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "recode 1 bit (.%d) at bitpos %d", Bit, pos); #endif } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_codeByteNumber | +--------------------------------------------------------------------+ PURPOSE: Converts the value (val) into a Bitstring with the length (len) and writes it at the actual position into the bitstream globs->bitbuf. The maximum value of (len) is 8. If the value is greater then (2^len)-1 it will be truncated. */ void bf_codeByteNumber (UBYTE len, UBYTE val, T_CCD_Globs *globs) { UBYTE *p; t_conv16 conv16; #ifdef DEBUG_CCD TRACE_CCD (globs, "codeByteNumber:writing %d bits (.%s) at byte %d.%d", len, ccd_BITIMAGE (val, (ULONG) len, globs), globs->bytepos, globs->byteoffs); #endif p = globs->bitbuf + globs->bytepos; conv16.s = (USHORT) val; conv16.s <<= (16 - len - globs->byteoffs); *p++ |= conv16.c[MSB_POS]; if ((globs->byteoffs + len) > 8) *p |= conv16.c[LSB_POS]; bf_incBitpos (len, globs); } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_codeLongNumber | +--------------------------------------------------------------------+ PURPOSE : This funtion writes the numeric content of the var to the aktual position into the bitstream referenced by globs->bitbuf. */ void bf_codeLongNumber (UBYTE len, ULONG val, T_CCD_Globs *globs) { UBYTE wBits = len + globs->byteoffs; U8 *MsgBuf = (U8*)(globs->bitbuf + globs->bytepos); #ifdef DEBUG_CCD TRACE_CCD (globs, "codeLongNumber: writing %d bits (.%s) at byte %d.%d", len, ccd_BITIMAGE (val, (ULONG) len, globs), globs->bytepos, globs->byteoffs); #endif if (len > 8) { t_conv32 conv; conv.l = val; conv.l &= ccd_bitfun_mask[len]; conv.l <<= (32 - wBits); MsgBuf[0] |= conv.c[MSW_POS + MSB_POS]; MsgBuf[1] = conv.c[MSW_POS + LSB_POS]; if (wBits > 16) { MsgBuf[2] = conv.c[LSW_POS + MSB_POS]; if (wBits > 24) { MsgBuf[3] = conv.c[LSW_POS + LSB_POS]; } } } else { t_conv16 conv; conv.s = (USHORT) val; conv.s &= (USHORT) ccd_bitfun_mask[len]; conv.s <<= (16 - wBits); MsgBuf[0] |= conv.c[MSB_POS]; if (wBits > 8) { MsgBuf[1] = conv.c[LSB_POS]; } } bf_incBitpos (len, globs); } #endif /* !RUN_FLASH */ #if 0 /* not used - maybe for the future */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : BITFUN | | STATE : code ROUTINE : bf_swapBits | +--------------------------------------------------------------------+ PURPOSE : reads (len) Bits from the Bitsream (1-8) and swap this part with the next (len) bits in the bitstream. The read/write pointer of the bitstream left unchanged. This function is used for swapping the nibbles in some ugly coded GSM messages. */ void bf_swapBits (ULONG len, T_CCD_Globs *globs) { UBYTE s1, s2; USHORT s21; USHORT startpos = globs->bitpos; UBYTE *p; t_conv32 conv32; if (len > 0 AND len <= 8) { #ifdef DEBUG_CCD TRACE_CCD (globs, "swapping %d bits", len); #endif /* * read bitstring#1 */ s1 = bf_decodeByteNumber (len, globs); /* * read bitstring#2 */ s2 = bf_decodeByteNumber (len, globs); /* * concat bitstring#2 and bitstring#1 */ s21 = (USHORT) s2 <<len; s21 |= s1; /* * recode it into the bitstream */ bf_setBitpos (startpos, globs); p = globs->bitbuf + globs->bytepos; conv32.l = (ULONG) s21; conv32.l <<= (32 - len) - globs->byteoffs; *p++ |= conv32.c[MSW_POS + MSB_POS]; *p++ |= conv32.c[MSW_POS + LSB_POS]; *p++ |= conv32.c[LSW_POS + MSB_POS]; *p |= conv32.c[LSW_POS + LSB_POS]; bf_setBitpos (startpos, globs); bf_recodeShortNumber (startpos, (UBYTE) (len<<1), s21, globs); bf_setBitpos (startpos, globs); } } #endif /* !RUN_FLASH */ #endif