FreeCalypso > hg > fc-magnetite
view src/gpf3/ccd/asn1_integ_ext.c @ 234:b870b6a44d31
l1audio and l1tm reconstructed source imported from tcs211-l1-reconst
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Mon, 20 Mar 2017 00:51:20 +0000 |
parents | c41a534f33c6 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : | Modul : asn1_integ_ext.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 : Encoding and decoding functions for ASN1_INTEGER_EXTENSIBLE type +----------------------------------------------------------------------------- */ /* * Standard definitions like UCHAR, ERROR etc. */ #include "typedefs.h" #include "header.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" /* * Prototypes and constants in the common part of ccd */ #include "ccd.h" /* * Declaration of coder/decoder tables */ #include "ccdtable.h" #include "ccddata.h" #ifndef RUN_INT_RAM /* +------------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : asn1_integ_ext | | STATE : code ROUTINE : cdc_asn1_integ_ext_decode | +------------------------------------------------------------------------+ PURPOSE : Decode UNALIGNED PER extensible ENUMERATED and INTEGER type PER-visible constraints restrict the integer value to be a constrained whole number. This gives a lower and an upper bound for the integer. The lb is also called offset. The encoded value is the difference between the actual and the offset value. A possible and meant default value is never encoded. If the value is in the extension root, it will be encoded as a normally small non-negative whole number. Otherwise it will be encoded in the smalles number of bits needed to express every enumeration. */ SHORT cdc_asn1_integ_ext_decode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs) { ULONG repeat=1, max_rep=1, var_ref, val_ref; BOOL DefaultFound= FALSE; S32 IfnotPresent; UBYTE *value, *old_pstruct = NULL; var_ref = (ULONG) melem[e_ref].elemRef; #ifdef DEBUG_CCD #ifndef CCD_SYMBOLS TRACE_CCD (globs, "cdc_asn1_integ_ext_decode()"); #else TRACE_CCD (globs, "cdc_asn1_integ_ext_decode() %s", ccddata_get_alias((USHORT) e_ref, 1)); #endif #endif /* * For integer with only one possible value in the extension root: * If the extensinon bit is 0, the encoded value is in the extension root. * In this case no arrays are expected. * For other types: * The extension bit and the value will be read in the while-loop below. */ if (mvar[var_ref].bSize EQ 0) { if (bf_readBit (globs) EQ FALSE) { Read_unique_Integer (e_ref, globs); return 1; } else { bf_incBitpos (-1, globs); } } val_ref = (ULONG) mvar[var_ref].valueDefs; /* * Set pstrcutOffs and max_rep. Check the valid flag in case of optional elements. */ if (PER_CommonBegin (e_ref, &max_rep, globs) NEQ ccdOK) return 1; #ifdef DYNAMIC_ARRAYS /* * Allocate memory if this is a pointer type (dynamic array) */ if ( is_pointer_type(e_ref) ) { old_pstruct = globs->pstruct; if ( PER_allocmem_and_update(e_ref, max_rep, globs) NEQ ccdOK) /* No memory - Return. Error already set in function call above. */ return 1; } #endif /* * Check if there is a default value for the element. * If yes, just set it aside for a later comparision. */ if (mval[val_ref+1].isDefault EQ 2) { IfnotPresent = mval[val_ref+1].startValue; DefaultFound = TRUE; } /* * Decode all elements of the array. */ while ( repeat <= max_rep) { value = globs->pstruct + globs->pstructOffs; /* * There is a default value for this integer elment. * While decoding of the ASN1-SEQUENCE contiaing this integer * we have used a particular byte of C-structure to signalize * the decoding of a default value (byte set to 0). */ if (DefaultFound AND !globs->pstruct[melem[e_ref].structOffs]) { switch (mvar[var_ref].cType) { case 'B': *(U8*) value = (U8) IfnotPresent; break; case 'C': *(S8*) value = (S8) IfnotPresent; break; case 'S': *(U16*) value = (U16) IfnotPresent; break; case 'T': *(S16*) value = (S16) IfnotPresent; break; case 'L': *(U32*) value = (U32) IfnotPresent; break; case 'M': *(S32*) value = (S32) IfnotPresent; break; default: ccd_recordFault (globs,ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref, value); break; } } /* * There is no default value defined for this integer elment. * Read the value from the bit buffer. */ else { U32 ub, lb; ULONG readBits; U32 DecodedValue; lb = mval[val_ref].startValue; ub = mval[val_ref].endValue; /* * Read first the extensinon bit. * Then the non-negative value from the air message. */ if (bf_readBit (globs) EQ FALSE) { readBits = bf_getBits (mvar[var_ref].bSize, globs); } /* Value out of the extension root. */ else { U16 calcRef = calcidx[melem[e_ref].calcIdxRef].condCalcRef; /* * Get max value of integer within the extension root. */ if (calcRef EQ NO_REF OR calc[calcRef].operation NEQ 'P') { ccd_recordFault (globs, ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref, globs->pstruct+globs->pstructOffs); } else { lb = calc[calcRef].operand; } readBits = Read_NormallySmallNonNegativeWholeNr (globs); } if (readBits <= (U32)(ub - lb)) { DecodedValue = lb + readBits; /* * Add the offset to the read value to get the actual one. */ switch (mvar[var_ref].cType) { case 'B': *(U8*) value = (U8) DecodedValue; break; case 'C': *(S8*) value = (S8) DecodedValue; break; case 'S': *(U16*) value = (U16) DecodedValue; break; case 'T': *(S16*) value = (S16) DecodedValue; break; case 'L': *(U32*) value = (U32) DecodedValue; break; case 'M': *(S32*) value = (S32) DecodedValue; break; default: ccd_recordFault (globs,ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref, value); break; } } else { #ifdef DEBUG_CCD TRACE_CCD (globs, "integer out of range! %ld require: %ld .. %ld ", DecodedValue, lb, ub); #endif if (melem[e_ref].optional) ccd_recordFault (globs, ERR_ASN1_OPT_IE, CONTINUE, (USHORT) e_ref, value); else ccd_recordFault (globs, ERR_ASN1_MAND_IE, CONTINUE, (USHORT) e_ref, value); } } repeat ++; globs->pstructOffs += mvar[var_ref].cSize; }/*while*/ #ifdef DYNAMIC_ARRAYS if (old_pstruct NEQ NULL) globs->pstruct = old_pstruct; #endif return 1; } #endif /* !RUN_INT_RAM */ #ifndef RUN_INT_RAM /* +------------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : asn1_integ_ext | | STATE : code ROUTINE : cdc_asn1_integ_ext_encode | +------------------------------------------------------------------------+ PURPOSE : UNALIGNED PER extensible ENUMERATED and INTEGER type PER-visible constraints restrict the integer value to be a constrained whole number. This gives a lower and an upper bound for the integer. The lb is also called offset. The encoded value is the difference between the actual and the offset value. A possible and meant default value is never encoded. If the value is in the extension root, it will be encoded as a normally small non-negative whole number. Otherwise it will be encoded in the smalles number of bits needed to express every enumeration. ----------------------------------------------- | extension | value encoded as a normally | | bit = 1 | non-negtive integer whole number | ----------------------------------------------- ----------------------------------------------- | extension | value encoded in the bit size | | bit = 0 | needed to express ub - lb | ----------------------------------------------- */ SHORT cdc_asn1_integ_ext_encode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs) { ULONG repeat=1, max_rep=1, var_ref, val_ref; BOOL DefaultFound= FALSE; S32 IfnotPresent; U8 *base_pstruct; #ifdef DEBUG_CCD #ifndef CCD_SYMBOLS TRACE_CCD (globs, "cdc_asn1_integ_ext_encode()"); #else TRACE_CCD (globs, "cdc_asn1_integ_ext_encode() %s", ccddata_get_alias((USHORT) e_ref, 1)); #endif #endif var_ref = (ULONG) melem[e_ref].elemRef; val_ref = (ULONG) mvar[var_ref].valueDefs; /* * Set pstrcutOffs and max_rep. Check the valid flag in case of optional elements. */ if (PER_CommonBegin (e_ref, &max_rep, globs) NEQ ccdOK) return 1; /* * Check if there is a default value for the element. * If yes, just set it aside for a later comparision. */ if (mval[val_ref+1].isDefault EQ 2) { IfnotPresent = mval[val_ref+1].startValue; DefaultFound = TRUE; } #ifdef DYNAMIC_ARRAYS if ( is_pointer_type(e_ref) ) { base_pstruct = *(U8 **)(globs->pstruct + globs->pstructOffs); if (ccd_check_pointer(base_pstruct) == ccdOK) { globs->pstructOffs = 0; } else { ccd_recordFault (globs, ERR_INVALID_PTR, BREAK, (USHORT) e_ref, &globs->pstruct[globs->pstructOffs]); return 1; } } else #endif base_pstruct = globs->pstruct; /* * Encode all elements of the array. */ while ( repeat <= max_rep) { S32 ub, lb, value; U32 extension_lb; UBYTE *p; U16 calcRef = calcidx[melem[e_ref].calcIdxRef].condCalcRef; /* * Get offset value of integer in the extension addition. */ if (calcRef EQ NO_REF OR calc[calcRef].operation NEQ 'P') { ccd_recordFault (globs, ERR_DEFECT_CCDDATA, BREAK,(USHORT) e_ref, globs->pstruct+globs->pstructOffs); return 1; } else { extension_lb = calc[calcRef].operand; } /* * setup the read pointer to the element in the C-structure */ p = base_pstruct + globs->pstructOffs; switch (mvar[var_ref].cType) { case 'B': value = (S32)*(UBYTE *) p; break; case 'C': value = (S32)*(S8 *) p; break; case 'S': value = (S32)*(USHORT *) p; break; case 'T': value = (S32)*(S16 *) p; break; case 'L': /* * This type casting can be critical. * Thus the case of bSize=32 will be handled separately. */ if (mvar[var_ref].bSize < 32) { value = (S32)*(U32 *) p; } break; case 'M': value = *(S32 *) p; break; default: ccd_recordFault (globs,ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref, p); return 1; } if (mvar[var_ref].cType EQ 'L' AND (mvar[var_ref].bSize EQ 32)) { U32 CriticalValue; CriticalValue = *(U32 *) p; if (CriticalValue >= extension_lb) { bf_writeBit (1, globs); if (!DefaultFound OR (U32)IfnotPresent NEQ CriticalValue) Write_NormallySmallNonNegativeWholeNr (CriticalValue - extension_lb, globs); } else { bf_writeBit (0, globs); if (!DefaultFound OR (U32)IfnotPresent NEQ CriticalValue) { U32 lb, ub; lb = (U32) mval[val_ref].startValue; ub = (U32) mval[val_ref].endValue; if (lb <= CriticalValue && CriticalValue <= ub) { bf_writeVal (CriticalValue - lb, mvar[var_ref].bSize, globs); } else { #ifdef DEBUG_CCD TRACE_CCD (globs, "integer out of range! %ld require: %ld .. %ld ", value, lb, ub); #endif ccd_recordFault (globs, ERR_INT_VALUE, CONTINUE, (USHORT) e_ref, p); } } } } else { /* * Encode only non-default values. */ if (!DefaultFound OR IfnotPresent NEQ value) { /* * Set the extension bit to 0 if the value belongs to the extension root. * Otherwise set it to 1. * A non-negative-binary-integer will be encoded since the offset must * be subtracted from the value read from the C-structure. */ lb = mval[val_ref].startValue; ub = mval[val_ref].endValue; if (value >= (S32)extension_lb AND value <= ub) { bf_writeBit (1, globs); Write_NormallySmallNonNegativeWholeNr ((U32)value - extension_lb, globs); } else if (lb <= value AND value <= ub) { bf_writeBit (0, globs); /* * Do not encode single valued extension roots. */ if (mvar[var_ref].bSize NEQ 0) bf_writeVal ((ULONG)(value-lb), mvar[var_ref].bSize, globs); } else { #ifdef DEBUG_CCD TRACE_CCD (globs, "integer out of range! %ld require: %ld .. %ld ", value, lb, ub); #endif ccd_recordFault (globs, ERR_INT_VALUE, CONTINUE, (USHORT) e_ref, p); } } } /* value not critical*/ repeat ++; globs->pstructOffs += mvar[var_ref].cSize; }/* while-loop */ return 1; } #endif /* !RUN_INT_RAM */