/* +----------------------------------------------------------------------------- | Project : | Modul : cdc_std.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 : Condat Conder Decoder | Definitions of non protocol specific encoding and decoding | functions+----------------------------------------------------------------------------- */ #define CCD_STD_C#ifdef _MSDOS#include <dos.h>#include <conio.h>#endif/* * standard definitions like UCHAR, ERROR etc. */#include "typedefs.h"#include "header.h"#include <string.h>/* * Prototypes of ccd (USE_DRIVER EQ undef) for prototypes only * look at ccdapi.h. */#undef USE_DRIVER#include "ccdapi.h"/* * Types and functions for bit access and manipulation */#include "ccd_globs.h"#include "bitfun.h"/* * Declaration of coder/decoder tables and/or functions to access them */#include "ccdtable.h"#include "ccddata.h"/* * Prototypes of ccd internal functions */#include "ccd.h"/* * Need memory allocation functions for dynamic arrays (pointers) */#ifdef DYNAMIC_ARRAYS#include "vsi.h"#endif#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : cdc_decodeElemvalue |+--------------------------------------------------------------------+ PURPOSE : Performs a standard decoding for a given elem table entry. This means for non structured elements that 1-n bits are read from the bitstream and write to a C-Variable in a machine dependent format. For structured elements an (indirect) recursive call to cc_decodeComposition() is performed. If the element is a bitbuffer with variable size, the repeat value gives the number of bits to read from the bitstream into the buffer. The maxBitpos indicates the maximum valid position for the readpointer of the bitstream while decoding this element. If the readpointer break this boundary, this element will not be decoded.*/void cdc_decodeElemvalue (ULONG e_ref, ULONG *repeat, T_CCD_Globs *globs){ UBYTE *ActStructpos; ULONG i; UBYTE spareLen; /* * element is a bit field of variable length */ if ((melem[e_ref].repType == 'b') || (melem[e_ref].repType == 's')) { if (*repeat > (ULONG) (globs->maxBitpos-globs->bitpos)) { ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); *repeat = MINIMUM (*repeat, (ULONG) (globs->maxBitpos-globs->bitpos)); } if (melem[e_ref].repType == 'b') { if (mvar[melem[e_ref].elemRef].cType EQ 'X') bf_readBitChunk (*repeat, globs); else bf_readBits (*repeat, globs); } else { U16 finalBP = globs->bitpos + (USHORT) *repeat; /* Store the limit. This comp may contain other comps as bitstring. */ globs->maxBitpos = finalBP; ActStructpos = globs->pstruct; globs->pstruct += globs->pstructOffs;#ifdef DEBUG_CCD#ifdef CCD_SYMBOLS TRACE_CCD (globs, "decoding composition %s as a bit array", mcomp[melem[e_ref].elemRef].name);#else TRACE_CCD (globs, "decoding composition %d", melem[e_ref].elemRef);#endif#endif ccd_decodeComposition ((ULONG) (melem[e_ref].elemRef), globs); if (finalBP < globs->bitpos) { ccd_recordFault (globs, ERR_BITSTR_COMP, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } bf_setBitpos (finalBP, globs); /* Update maxBitpos to avoid an early end of decoding. */ globs->maxBitpos = globs->buflen; globs->pstruct = ActStructpos; } } else { /* * For pointer types, globs->pstruct is already set to point to * the new memory area, and these types are not treated differently * from non-pointer types. */ i=0; switch (melem[e_ref].elemType) { case 'R': /* Pointer to (possible array of) basetype */ case 'F': /* Code-transparent pointer to (possible array of) basetype */ case 'V': while (i < *repeat) { if (globs->bitpos < globs->maxBitpos) {#ifdef DEBUG_CCD#ifdef CCD_SYMBOLS TRACE_CCD (globs, "decoding var %s", ccddata_get_alias((USHORT) e_ref, 1));#else TRACE_CCD (globs, "decoding var %d", melem[e_ref].elemRef);#endif#endif if (mvar[melem[e_ref].elemRef].cType EQ 'X') bf_readBitChunk (mvar[melem[e_ref].elemRef].bSize, globs); else bf_readBits (mvar[melem[e_ref].elemRef].bSize, globs); globs->pstructOffs += mvar[melem[e_ref].elemRef].cSize; i++; } else { if (melem[e_ref].repType != 'i') { ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } break; } } break; case 'D': /* Pointer to a composition */ case 'P': /* Code transparent pointer to a comp */ case 'C': /* Element is a composition. */ case 'U': /* Element is a union. */ /* * Store the actual structure position. */ ActStructpos = globs->pstruct; globs->pstruct += globs->pstructOffs; while (i < *repeat) { if (globs->bitpos < globs->maxBitpos) {#ifdef DEBUG_CCD#ifdef CCD_SYMBOLS TRACE_CCD (globs, "decoding composition %s", mcomp[melem[e_ref].elemRef].name);#else TRACE_CCD (globs, "decoding composition %d", melem[e_ref].elemRef);#endif#endif /* * recursiv call */ ccd_decodeComposition ((ULONG) (melem[e_ref].elemRef), globs); globs->pstruct += mcomp[melem[e_ref].elemRef].cSize; i++; } else { if (melem[e_ref].repType != 'i') { ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } break; } } /* * restore the write pointer */ globs->pstruct = ActStructpos; break; case 'S': /* Element is a spare. */ { spareLen = spare[melem[e_ref].elemRef].bSize; /* * Do not decode padding bits. They are not relevant. * Just adjust the position pointer in the bit stream buffer. */ while (i < *repeat) { if (globs->bitpos < globs->maxBitpos) {#ifdef DEBUG_CCD TRACE_CCD (globs, "decoding spare");#endif bf_incBitpos (spareLen, globs); i++; } else break; } break; } } *repeat = i; }}#endif /* !RUN_FLASH */#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : cdc_encodeElemvalue |+--------------------------------------------------------------------+ PURPOSE : Performs a standard encoding for a given elem table entry. This means for non structured elements that 1-n bits are read from the bitstream and write to a C-Variable in a machine dependent format. For structured elements an (indirect) recursive call to cc_decodeComposition() is performed. If the element is a bitbuffer with variable size, the repeat value gives the number of bits to write from the buffer into the bitstream.*/void cdc_encodeElemvalue (ULONG e_ref, ULONG repeat, T_CCD_Globs *globs){ UBYTE *ActStructpos = NULL; ULONG i; UBYTE spareLen; /* * Element is a bit field of variable length. */ if (melem[e_ref].repType == 'b') { if (mvar[melem[e_ref].elemRef].cType EQ 'X') bf_writeBitChunk (repeat, globs); else bf_writeBits (repeat, globs); } /* * Element is a structured IE defined as bit string. */ else if (melem[e_ref].repType == 's') { U16 finalBP = (USHORT) (globs->bitpos + repeat); ActStructpos = globs->pstruct; globs->pstruct += globs->pstructOffs;#ifdef DEBUG_CCD#ifdef CCD_SYMBOLS TRACE_CCD (globs, "encoding composition %s as a bit array", mcomp[melem[e_ref].elemRef].name);#else TRACE_CCD (globs, "encoding composition %d", melem[e_ref].elemRef);#endif#endif ccd_encodeComposition ((ULONG) melem[e_ref].elemRef, globs); if (finalBP < globs->bitpos) { ccd_recordFault (globs, ERR_BITSTR_COMP, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } bf_setBitpos (finalBP, globs); globs->pstruct = ActStructpos; } else { /* * For pointer types, globs->pstruct is already set to point to * the new memory area, and these types are not treated differently * from non-pointer types. */ switch(melem[e_ref].elemType) { case 'R': /* Pointer to (possible array of) basetype */ case 'F': /* Code-transparent pointer to (possible array of) basetype */ case 'V': for (i=0; i<repeat; i++) { #ifdef DEBUG_CCD #ifdef CCD_SYMBOLS TRACE_CCD (globs, "encoding var %s", ccddata_get_alias((USHORT) e_ref, 1)); #else TRACE_CCD (globs, "encoding var %s", melem[e_ref].elemRef); #endif #endif if (mvar[melem[e_ref].elemRef].cType EQ 'X') bf_writeBitChunk (mvar[melem[e_ref].elemRef].bSize, globs); else bf_writeBits (mvar[melem[e_ref].elemRef].bSize, globs); globs->pstructOffs += mvar[melem[e_ref].elemRef].cSize; } break; case 'D': /* Pointer to a composition (already dereferenced) */ case 'P': /* Code transparent pointer to a comp (already dereferenced) */ case 'C': /* Element is a composition. */ case 'U': /* Element is a union. */ /* * store the actual structure position */ ActStructpos = globs->pstruct; globs->pstruct += globs->pstructOffs; for (i=0; i<repeat; i++) { #ifdef DEBUG_CCD #ifdef CCD_SYMBOLS TRACE_CCD (globs, "encoding composition %s", mcomp[melem[e_ref].elemRef].name); #else TRACE_CCD (globs, "encoding composition %d", melem[e_ref].elemRef); #endif #endif ccd_encodeComposition ((ULONG) melem[e_ref].elemRef, globs); /* recursiv call */ globs->pstruct += mcomp[melem[e_ref].elemRef].cSize; } /* * restore the write pointer */ globs->pstruct = ActStructpos; break; case 'S': /* element is a spare */ { spareLen = spare[melem[e_ref].elemRef].bSize; /* * encode the spare */ for (i=0; i < repeat; i++) { #ifdef DEBUG_CCD TRACE_CCD (globs, "encoding spare"); #endif bf_codeLongNumber (spareLen, spare[melem[e_ref].elemRef].value, globs); } break; } } }}#endif /* !RUN_FLASH */#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : cdc_STD_decode |+--------------------------------------------------------------------+ PURPOSE : Performs a standard decoding for a given elem table entry. This means for non structured elements that 1-n bits are read from the bitstream and write to a C-Variable in a machine dependent format. For structured elements an (indirect) recursive call to cc_decodeComposition() is performed. The element may be conditional and/or repeatable.*/SHORT cdc_std_decode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs){ ULONG repeat, amount, act_offset; BOOL is_variable; U8 *old_pstruct = NULL; ULONG cix_ref, num_prolog_steps, prolog_step_ref;#ifdef DEBUG_CCD #ifndef CCD_SYMBOLS TRACE_CCD (globs, "cdc_std_decode()"); #else TRACE_CCD (globs, "cdc_std_decode() %s", ccddata_get_alias((USHORT) e_ref, 1)); #endif#endif cix_ref = melem[e_ref].calcIdxRef; num_prolog_steps = calcidx[cix_ref].numPrologSteps; prolog_step_ref = calcidx[cix_ref].prologStepRef; /* * if this element is conditional, check the condition */ if (calcidx[cix_ref].numCondCalcs NEQ 0 AND ! ccd_conditionOK (e_ref, globs)) return 1; /* * if this element has a defined prologue * we have to process it before decoding the bitstream * If there are some epilogue expressions to be processed for this element * (rare cases) the result here will be a reading of 0 to an internal * register. The valid processing of expression takes place after the * decoding of the element. */ if (num_prolog_steps) { ccd_performOperations (num_prolog_steps, prolog_step_ref, globs); } /* * if this element is repeatable, and the number of * repeats depends on another element, calculate the repeater */ if (melem[e_ref].repType NEQ ' ') { is_variable = ccd_calculateRep (e_ref, &repeat, &act_offset, globs); } else { repeat = 1; is_variable = FALSE; } if (melem[e_ref].elemType NEQ 'S') { /* * Element is not a SPARE. * Setup the offset into the C-structure for this element */ globs->pstructOffs = melem[e_ref].structOffs; if (melem[e_ref].optional) { /* 20010621 MVJ: Dynamic array addition. * Postpone optional flag setting for non-code transparent * pointer types ('P', 'Q', 'R'). * For these types, the optional flag is the pointer itself. * These types cannot be set yet, as the pointer may be * preceeded by a counter octet, a union tag id octet etc. */ if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R') globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE; } if (is_variable) { /* * for variable sized elements store the min-value * as counter into the C-Structure (c_xxx). */ if (act_offset > 65535) *(ULONG *) (globs->pstruct + globs->pstructOffs++) = repeat; else if (act_offset > 255) *(USHORT *) (globs->pstruct + globs->pstructOffs++) = (USHORT) repeat; else globs->pstruct[globs->pstructOffs] = (UBYTE) repeat; globs->pstructOffs++; } } #ifdef DYNAMIC_ARRAYS /* * MVJ: Dynamic array addition. * Check for pointer types; allocate memory if necessary. */ if ( is_pointer_type(e_ref) ) { U32 cSize; U8 *addr; /* * Find size to allocate; * - Read from mcomp or mvar according to type */ cSize = (ULONG)((melem[e_ref].elemType EQ 'V' OR melem[e_ref].elemType EQ 'R') ? mvar[melem[e_ref].elemRef].cSize : mcomp[melem[e_ref].elemRef].cSize ) * repeat; /* * Allocate additional memory */ addr = (U8 *)DP_ALLOC( cSize, globs->alloc_head, DP_NO_FRAME_GUESS); /* If no memory, log error and return immediately */ if (addr EQ NULL) { ccd_setError (globs, ERR_NO_MEM, BREAK, (USHORT) -1); return 1; } else memset (addr, 0, (size_t)cSize); /* * Memory allocated; * 1. Save old "globs->pstruct" variables * 2. Store pointer to freshly allocated memory area in structure * 3. Initialize pstruct to point to the freshly allocated memory area. * 4. Initialize pstructOffs to 0 to start decoding at offset 0 * in the new memory area. */ old_pstruct = globs->pstruct; *(U8 **)(globs->pstruct + globs->pstructOffs) = addr; globs->pstruct = addr; globs->pstructOffs = 0; }#endif amount = repeat; cdc_decodeElemvalue (e_ref, &amount, globs); /* * process the epilogue expression for this element if there is any */ if (num_prolog_steps) { if ( (calc[prolog_step_ref+1].operation EQ 'K') || (calc[prolog_step_ref+1].operation EQ 'C') || (calc[prolog_step_ref+1].operation EQ 's')) { ccd_performOperations (num_prolog_steps, prolog_step_ref, globs); } }#ifdef DYNAMIC_ARRAYS /* * Restore globs->pstruct for possible use below */ if (old_pstruct NEQ NULL) { globs->pstruct = old_pstruct; }#endif if (amount NEQ repeat AND is_variable) { /* * if the decoded elements are not equal the specified * repeat value, because the bitstream or the IE ended, * store the new c_xxx value. */ globs->pstructOffs = melem[e_ref].structOffs; if (melem[e_ref].optional) globs->pstructOffs++; if (act_offset > 65535) *(ULONG *) (globs->pstruct + globs->pstructOffs) = amount; else if (act_offset > 255) *(USHORT *) (globs->pstruct + globs->pstructOffs) = (USHORT) amount; else globs->pstruct[globs->pstructOffs] = (UBYTE) amount; if (melem[e_ref].repType NEQ 'i') { /* * if this element is not of the repeat style 'interval' * ([X..Y] where X and Y are constants) we have to generate * an ccd error because some outstanding repeats are missing. */ ccd_setError (globs, ERR_MAND_ELEM_MISS, CONTINUE, (USHORT) -1); } } return 1;}#endif /* !RUN_FLASH */#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : cdc_std_encode |+--------------------------------------------------------------------+ PURPOSE : Performs a standard encoding for a given elem table entry. This means for non structured elements that m bytes read from the C-Variable, converted to MSB-first format and write 1-n bits at the end of the bitstream. For structured elements an (indirect) recursive call to ccd_encodeComposition() is performed. The element may be conditional and/or repeatable.*/SHORT cdc_std_encode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs){ ULONG repeat, max_rep; BOOL is_variable; ULONG cix_ref, num_prolog_steps, prolog_step_ref;#ifdef DYNAMIC_ARRAYS U8 *old_pstruct = NULL;#endif#ifdef DEBUG_CCD #ifndef CCD_SYMBOLS TRACE_CCD (globs, "cdc_std_encode()"); #else TRACE_CCD (globs, "cdc_std_encode() %s", ccddata_get_alias((USHORT) e_ref, 1)); #endif#endif cix_ref = melem[e_ref].calcIdxRef; num_prolog_steps = calcidx[cix_ref].numPrologSteps; prolog_step_ref = calcidx[cix_ref].prologStepRef; /* * if this element is conditional, check the condition */ if (calcidx[cix_ref].numCondCalcs NEQ 0 AND ! ccd_conditionOK (e_ref, globs)) return 1; /* * if this element have a defined Prolog * we have to process it before decoding the bitstream */ if (num_prolog_steps) { ccd_performOperations (num_prolog_steps, prolog_step_ref, globs); } if (melem[e_ref].elemType NEQ 'S') { /* * Element is not a SPARE. * Setup the readpointer into the C-structure for this element * MVJ: In case of pointer types, the pstructOffs must be * the offset into the memory area pointed to. CCDGEN must * ensure this holds true. */ globs->pstructOffs = melem[e_ref].structOffs; if (melem[e_ref].optional) { /* * for optional elements check the valid-flag in the C-struct. * Spare elements does not have a corresponding valid flag. For * the spare elements we have to calculate and check the * condition to decide if this elements have to be coded. */ /* 20010621 MVJ: Dynamic array addition. * Postpone optional check for non-code transparent pointer * types ('P', 'Q', 'R'). * For these types, the optional flag is the pointer itself. * These types cannot be checked yet, as the pointer may be * preceeded by a counter octet, a union tag id octet etc. */ if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R') { if (globs->pstruct[globs->pstructOffs++] == FALSE) { return 1; }#ifdef DEBUG_CCD else if (globs->pstruct [melem[e_ref].structOffs] != TRUE) { TRACE_CCD (globs, "Ambiguous value for valid flag!\n...assumed 1 for ccdID=%d", e_ref); }#endif } } if ((melem[e_ref].repType EQ 'v' OR melem[e_ref].repType EQ 'i')) { /* * for variable sized elements read the amount * of repeats out of the C-Structure (c_xxx). * If the number of repeats given by the C-Structure * exceeds the allowed value (maxRepeat) CCD gives a warning! */ if (melem[e_ref].maxRepeat > 255) { ULONG count = (ULONG) (* (USHORT *)(globs->pstruct + globs->pstructOffs++)); repeat = MINIMUM (count, (ULONG) melem[e_ref].maxRepeat); if (repeat < count) ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } else { repeat = (ULONG)MINIMUM (globs->pstruct[globs->pstructOffs], melem[e_ref].maxRepeat); if ( repeat < (ULONG) (globs->pstruct[globs->pstructOffs]) ) ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } globs->pstructOffs++; } else if (melem[e_ref].repType EQ 'c') { repeat = (ULONG) melem[e_ref].maxRepeat; } else if (melem[e_ref].repType == 's' || melem[e_ref].repType == 'b') { switch (melem[e_ref].elemType) { case 'R': /* Pointer to (possible array of) basetype */ case 'F': /* Code-transparent pointer to (possible array of) basetype */ case 'V': globs->maxBitpos = globs->bitpos + mvar[melem[e_ref].elemRef].bSize; break; case 'D': /* Pointer to a composition */ case 'P': /* Code transparent pointer to a comp */ case 'C': /* Element is a composition. */ case 'E': /* Pointer to a union */ case 'Q': /* Code transparent pointer to a union */ case 'U': /* Element is a union. */ globs->maxBitpos = globs->bitpos + mcomp[melem[e_ref].elemRef].bSize; break; } is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs); } else repeat = 1; /* 20010621 MVJ: Dynamic array addition. * Check for non-code transparent pointer types ('P', 'Q', 'R'). * For these types, the optional flag is the pointer itself. * ASSUMPTION: The pointer may be preceeded by a counter octet, * a union tag id octet etc., but it is up to CCDGEN to ensure * word alignment (by inserting alignment bytes). Therefore * we just read from globs->pstruct[globs->pstructOffs]. */#ifdef DEBUG_CCD /* Check pointer alignment and re-align if necessary (should never happen) */ if ( is_pointer_type(e_ref) AND ((globs->pstructOffs & 3) NEQ 0)) { TRACE_CCD (globs, "cdc_STD_encode(): Pointer misaligned! pstruct=0x08x," " pstructOffs=0x%08x", globs->pstruct, globs->pstructOffs); globs->pstructOffs = (globs->pstructOffs + 3) & 3; }#endif#ifdef DYNAMIC_ARRAYS /* * MVJ: Perform pointer dereference for pointer types. * Also, check optionality for these types. */ if ( is_pointer_type(e_ref) ) { U8 *deref_pstruct; /* Get pointer value */ deref_pstruct = *(U8 **)&globs->pstruct[globs->pstructOffs]; /* * Strictly speaking the 'D' to 'F' types should not need this * check (should have returned after the optionality check above), * but it will catch stray NULL pointers (or uninitialized * valid flags) */ if (ccd_check_pointer(deref_pstruct) != ccdOK ) { ccd_recordFault (globs, ERR_INVALID_PTR, BREAK, (USHORT) e_ref, &globs->pstruct[globs->pstructOffs]); return 1; } /* * Pointer not NULL; * 1. Save old globs->pstruct and assign pointer to globs->pstruct * as new base. * 2. Set pstructOffs to 0 (zero) as the next offset will start * in the new memory area. */ old_pstruct = globs->pstruct; globs->pstruct = deref_pstruct; globs->pstructOffs = 0; }#endif /* DYNAMIC_ARRAYS */ } else { /* * for spare elements we have to calculate the conditions * and the repetitions because there are no valid-flags and * c_xxx variables in the C-structure to read. */ if (melem[e_ref].optional) { /* * Spare elements does not have a corresponding valid flag. * For the spare elements we have to calculate and check the * condition to decide if this elements have to be coded. */ if (calcidx[cix_ref].numCondCalcs NEQ 0 AND ! ccd_conditionOK (e_ref, globs)) return 1; } /* * if this spare is repeatable, calculate the amount of * repeats because there is no corresponding c_xxx element * in the C-Structure. */ if (melem[e_ref].repType NEQ ' ') { globs->maxBitpos = globs->bitpos + spare[melem[e_ref].elemRef].bSize; is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs); } else repeat = 1; } cdc_encodeElemvalue (e_ref, repeat, globs);#ifdef DYNAMIC_ARRAYS if ( old_pstruct NEQ NULL ) globs->pstruct = old_pstruct;#endif return 1;}#endif /* !RUN_FLASH *//* * some elementary bitfunctions *//* LSB,MSB Definitions for the CPUs */#ifdef M_INTEL#define MSB_POS 1#define LSB_POS 0#define MSW_POS 2#define LSW_POS 0#else /* M_INTEL */#ifdef M_MOTOROLA#define MSB_POS 0#define LSB_POS 1#define MSW_POS 0#define LSW_POS 2#endif /* M_MOTOROLA */#endif /* M_INTEL */extern const ULONG ccd_bitfun_mask[];/* * Table of one-bit values (2^X) * This unused variable is commented now in order to avoid some compiler * warnings like: variable "shift" (line xxx) is not usedLOCAL const UBYTE shift[] ={ 128, 64, 32, 16, 8, 4, 2, 1}; */#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : ccd_codeByte |+--------------------------------------------------------------------+ PURPOSE: encodes the value of (value) into a CPU-dependent bitstring. The length of the bitstring is specified throu (bitlen). The function copies the bitstring into the buffer (bitstream) at bit position (startbit). The bitlen may be between 1 and 8.*/BYTE CCDDATA_PREF(ccd_codeByte) (UBYTE * bitstream, USHORT startbit, USHORT bitlen, UBYTE value){ union { /* Conversion structure 2 Byte <-> unsigned short */ UBYTE c[2]; USHORT s; } conv; UBYTE *p, lshift; USHORT m; p = bitstream + (startbit >> 3); lshift = (16 - ((startbit & 7) + bitlen)); conv.c[MSB_POS] = p[0]; conv.c[LSB_POS] = p[1]; m = ((USHORT) ccd_bitfun_mask[bitlen]) << lshift; conv.s &= ~m; conv.s |= ((value << lshift) & m); p[0] = conv.c[MSB_POS]; p[1] = conv.c[LSB_POS]; return ccdOK;}#endif /* !RUN_FLASH */#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : ccd_decodeByte |+--------------------------------------------------------------------+ PURPOSE: decodes (bitlen) bits from the (bitstream) at position (startbit) and converts them to a numeric value (value) The bitlen may be between 1 and 8.*/BYTE CCDDATA_PREF(ccd_decodeByte) (UBYTE *bitstream, USHORT startbit, USHORT bitlen, UBYTE *value){ union { /* Conversion structure 2 Byte <-> unsigned short */ UBYTE c[2]; USHORT s; } conv; UBYTE *p; p = bitstream + (startbit >> 3); conv.c[MSB_POS] = *p++; conv.c[LSB_POS] = *p; conv.s >>= (16 - ((startbit & 7) + bitlen)); conv.s &= (USHORT) ccd_bitfun_mask[bitlen]; *value = (UBYTE) conv.s; return ccdOK;}#endif /* !RUN_FLASH */#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : ccd_codeLong |+--------------------------------------------------------------------+ PURPOSE: encodes the value of (value) into a CPU-dependent bitstring. The length of the bitstring is specified throu (bitlen). The function copies the bitstring into the buffer (bitstream) at bit position (startbit). The bitlen may be between 1 and 32.*/BYTE CCDDATA_PREF(ccd_codeLong) (UBYTE *bitstream, USHORT startbit, USHORT bitlen, ULONG value){ UBYTE *p; union { /* Conversion structure 4 Byte <-> unsigned long */ UBYTE c[4]; ULONG l; } conv; p = bitstream + (startbit >> 3); startbit &= 7; conv.l = value & ccd_bitfun_mask[bitlen]; conv.l <<= (32-bitlen-startbit); p[0] &= (UCHAR)~ccd_bitfun_mask[8-startbit]; switch ((USHORT)(startbit+bitlen-1) >> 3) { case 0: p[0] |= conv.c[MSW_POS+MSB_POS]; break; case 1: p[0] |= conv.c[MSW_POS+MSB_POS]; p[1] = conv.c[MSW_POS+LSB_POS]; break; case 2: p[0] |= conv.c[MSW_POS+MSB_POS]; p[1] = conv.c[MSW_POS+LSB_POS]; p[2] = conv.c[LSW_POS+MSB_POS]; break; case 3: p[0] |= conv.c[MSW_POS+MSB_POS]; p[1] = conv.c[MSW_POS+LSB_POS]; p[2] = conv.c[LSW_POS+MSB_POS]; p[3] = conv.c[LSW_POS+LSB_POS]; break; default: p[0] |= conv.c[MSW_POS+MSB_POS]; p[1] = conv.c[MSW_POS+LSB_POS]; p[2] = conv.c[LSW_POS+MSB_POS]; p[3] = conv.c[LSW_POS+LSB_POS]; p[4] = (UBYTE) ((value & 0xff) << (8-startbit)); break; } return ccdOK;}#endif /* !RUN_FLASH */#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : ccd_decodeLong |+--------------------------------------------------------------------+ PURPOSE: decodes (bitlen) bits from the (bitstream) at position (startbit) and converts them to a numeric value (value) The bitlen may be between 1 and 32.*/BYTE CCDDATA_PREF(ccd_decodeLong) (UBYTE *bitstream, USHORT startbit, USHORT bitlen, ULONG *value){ UBYTE *p; union { /* Conversion structure 4 Byte <-> unsigned long */ UBYTE c[4]; ULONG l; } conv; p = bitstream + (startbit >> 3); startbit &= 7; conv.l = 0L; switch ((USHORT)(startbit+bitlen-1) >> 3) { case 0: conv.c[MSW_POS+MSB_POS] = p[0]; conv.l <<= startbit; conv.l >>= (32-bitlen); break; case 1: conv.c[MSW_POS+MSB_POS] = p[0]; conv.c[MSW_POS+LSB_POS] = p[1]; conv.l <<= startbit; conv.l >>= (32-bitlen); break; case 2: conv.c[MSW_POS+MSB_POS] = p[0]; conv.c[MSW_POS+LSB_POS] = p[1]; conv.c[LSW_POS+MSB_POS] = p[2]; conv.l <<= startbit; conv.l >>= (32-bitlen); break; case 3: conv.c[MSW_POS+MSB_POS] = p[0]; conv.c[MSW_POS+LSB_POS] = p[1]; conv.c[LSW_POS+MSB_POS] = p[2]; conv.c[LSW_POS+LSB_POS] = p[3]; conv.l <<= startbit; conv.l >>= (32-bitlen); break; default: conv.c[MSW_POS+MSB_POS] = p[0]; conv.c[MSW_POS+LSB_POS] = p[1]; conv.c[LSW_POS+MSB_POS] = p[2]; conv.c[LSW_POS+LSB_POS] = p[3]; conv.l <<= startbit; conv.l >>= (32-bitlen); conv.c[LSW_POS+LSB_POS] |= (p[4] >> (8-startbit)); break; } *value = conv.l & ccd_bitfun_mask[bitlen]; return ccdOK;}#endif /* !RUN_FLASH */#ifndef RUN_FLASH/*+--------------------------------------------------------------------+| PROJECT : CCD (6144) MODULE : CCD || STATE : code ROUTINE : ccd_bitcopy |+--------------------------------------------------------------------+ PURPOSE: copys bitlen bits from the source buffer to the destination buffer. offset contains the position of the first bit in the source bitfield. This function may perform a leftshift to adjust the most significant bit on byte boundarys of the first byte in dest.*/void CCDDATA_PREF(ccd_bitcopy) (UBYTE *dest, UBYTE *source, USHORT bitlen, USHORT offset){ union { /* Conversion structure 2 Byte <-> unsigned short */ UBYTE c[2]; USHORT s; } conv; USHORT l_shift = offset & 7; USHORT bytes_to_copy = (bitlen >> 3); /* * go to the byte that contains the first valid bit. */ source += (offset >> 3); if (l_shift) { /* * shift and copy each byte */ while (bytes_to_copy--) { conv.c[MSB_POS] = *source; source++; conv.c[LSB_POS] = *source; conv.s <<= l_shift; *dest = conv.c[MSB_POS]; dest++; } } else { /* * no shift operation, do a memcopy; */ while (bytes_to_copy--) { *dest = *source; dest++; source++; } } /* * cutoff the garbage at the end of the bitstream */ *(dest-1) &= (UCHAR)(~ccd_bitfun_mask[(8-(bitlen&7))&7]);}#endif /* !RUN_FLASH */
