codeparm.c

手机加密通话软件

}

/**************************************************************************
*                                                                         *
* ROUTINE
*               Pack
*
* FUNCTION
*               Pack CELP parameters
* SYNOPSIS
*               Pack(NParams, Params, BitAllocs, NumPacked, Channel)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       NParams         int      i      Number of parameters to pack
*       Params          int      i      Frame of encoded analysis parameters
*       BitAllocs       int      i      Bit allocations for each parameter
*       NumPacked       int      o      Number of bits packed
*       Channel         int      o      Frame of channel bits
*
**************************************************************************/

void Pack(
int             NParams,
int             Params[],
int             BitAllocs[],
int             *NumPacked,
int             Channel[])
{
int             i, j, k=0;

        for(i=0; i<NParams; i++) { /* For each parameter */
          for(j=0;j<BitAllocs[i]; j++) { /* For each bit in each parameter */
            Channel[k++] = (Params[i] & (1<<j)) >> j;
          }
        }

        *NumPacked = k;

}

/**************************************************************************
*                                                                         *
* ROUTINE
*               Unpack
*
* FUNCTION
*               Unpack CELP parameters
* SYNOPSIS
*               Unpack(NParams, BitAllocs, Channel, NumUnpacked, Params)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       NParams         int      i      Number of parameters to unpack
*       BitAllocs       int      i      Bit allocations for each parameter
*       Channel         int      i      Frame of channel bits
*       NumUnpacked     int      o      Number of bits unpacked
*       Params          int      o      Frame of analysis parameters
*
**************************************************************************/

void Unpack(
int             NParams,
int             BitAllocs[],
int             Channel[],
int             *NumUnpacked,
int             Params[])
{
int     i, j, k=0;

        for(i=0; i<NParams; i++) { /* For each parameter */
          Params[i] = 0;
          for(j=0; j<BitAllocs[i]; j++) { /* For each bit in each parameter */
            Params[i] |= Channel[k++] << j;
          }
        }

        *NumUnpacked = k;

}

/**************************************************************************
*                                                                         *
* ROUTINE
*               ADelayEncode
*
* FUNCTION
*               Encode the Adaptive Delay
* SYNOPSIS
*               ADelayEncode(UDelay, QDelay)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       UDelay          fxpt_16  i      Unquantized adaptive delay
*       QDelay          int      o      Quantized adaptive delay
*
**************************************************************************/

#include "adencode.h"
extern fxpt_16 DelayTable[MAX_NUM_ADAPT];

void ACBDelayEncode(fxpt_16 Udelay, int *Qdelay)
{
        int             i, j;
        static int      even=FALSE;
        static int      LastIndex=1;
        int             MinDelayPtr, MaxDelayPtr;

        if(!even) {
                /* On odd frames search thru delay table until match found */
                for(i=0;i<MAX_NUM_ADAPT;i++) {
                        if (Udelay == DelayTable[i]) {
                                LastIndex = i;
                                break;
                        }
                }

                /*  Retrieve encoded delay value from table */
                *Qdelay = adencode[i];
        }
        else {
                /*  On even frames search for delta delay */
                MinDelayPtr = LastIndex - (NUM_DELTA_ADELAYS / 2 - 1);
                MaxDelayPtr = LastIndex + (NUM_DELTA_ADELAYS / 2);
                if (MinDelayPtr < 0) {
                        MinDelayPtr = 0;
                        MaxDelayPtr = NUM_DELTA_ADELAYS - 1;
                }
                if (MaxDelayPtr > NUM_FULL_ADELAYS-1) {
                        MaxDelayPtr = NUM_FULL_ADELAYS - 1;
                        MinDelayPtr = NUM_FULL_ADELAYS - NUM_DELTA_ADELAYS;
                }
                for(i=MinDelayPtr, j=0; i<=MaxDelayPtr; i++, j++) {
                        if (Udelay == DelayTable[i]) {
                                *Qdelay = j;
                                break;
                        }
                }
        }

        /*  Update even flag */
        even = (even) ? FALSE : TRUE;
}

/**************************************************************************
*                                                                         *
* ROUTINE
*               ACBDelayDecode
*
* FUNCTION
*               Decode the Adaptive Delay
* SYNOPSIS
*               ACBDelayDecode(QDelay, UDelay)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       QDelay          int      i      Quantized adaptive delay
*       UDelay          fxpt_16  o      Unquantized adaptive delay
*
**************************************************************************/

#include "addecode.h"

void ACBDelayDecode(int QDelay, fxpt_16 *UDelay)
{
        static int      even = FALSE;
        static int      LastIndex = 0;
        static int      first = TRUE;
        static int      DeltaDecodeTable[NUM_FULL_ADELAYS];
        int             MaxDelayPtr, MinDelayPtr;
        int             i;

        /*  Generate table for delta delay decoding */
        if(first) {
                first = FALSE;
                for (i = 0; i < NUM_FULL_ADELAYS; i++) {
                        DeltaDecodeTable[adencode[i]] = i;
                }
        }

        if (!even) {
                /*  On even subframes decode from table */
                *UDelay = addecode[QDelay];
                LastIndex = DeltaDecodeTable[QDelay];
        }
        else {
                /*  On odd subframes decode relative to previous frame */
                MinDelayPtr = LastIndex - (NUM_DELTA_ADELAYS / 2 - 1);
                MaxDelayPtr = LastIndex + (NUM_DELTA_ADELAYS / 2);
                if (MinDelayPtr < 0) {
                        MinDelayPtr = 0;
                        MaxDelayPtr = NUM_DELTA_ADELAYS - 1;
                }
                if (MaxDelayPtr > NUM_FULL_ADELAYS-1) {
                        MaxDelayPtr = NUM_FULL_ADELAYS - 1;
                        MinDelayPtr = NUM_FULL_ADELAYS - NUM_DELTA_ADELAYS;
                }
                *UDelay = DelayTable[MinDelayPtr + QDelay];
        }

        /*  Update even */
        even = (even) ? FALSE:TRUE;
}

/**************************************************************************
*                                                                         *
* ROUTINE
*               FS1016Encode
*
* FUNCTION
*               Translate from bit structure to FS1016 compatible array
* SYNOPSIS
*               FS1016Encode(InStruct, OutArray)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       InStruct        TX_BITS  i      Structure of quantized parameters
*       OutArray        int      o      Array of FS1016 compatible parameters
*
**************************************************************************/

int FS1016Encode(
TX_BITS InStruct,
int     OutArray[])
{
int     i, j=0;

FXPT_PUSHSTATE("FS1016Encode", -1.0, -1.0);
/*  Put the LSFs into the array */
        for(i=0;i<ORDER;i++)    {
          OutArray[j++] = InStruct.lsf[i];
        }

/*  Put each subframe's parameters into the array */
        for(i=0;i<NUM_SF;i++)   {
          OutArray[j++] = InStruct.AdaptiveDelay[i];
          OutArray[j++] = InStruct.AdaptiveGain[i];
          OutArray[j++] = InStruct.StochasticIndex[i];
          OutArray[j++] = InStruct.StochasticGain[i];
        }

/*  Now put in the Bishnu bit */
        OutArray[j++] = InStruct.Bishnu;

/*  Next the Hamming Code */
        OutArray[j++] = InStruct.Hamming;

/*  And last the sync bit */
        OutArray[j] = InStruct.Sync;

FXPT_POPSTATE();
/*  Let the calling routine know how many parameters were filled */
        return(j+1);

}

/**************************************************************************
*                                                                         *
* ROUTINE
*               FS1016Decode
*
* FUNCTION
*               Translate to bit structure from FS1016 compatible array
* SYNOPSIS
*               FS1016Encode(InArray, OutStruct)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       InArray         int      i      Array of FS1016 compatible parameters
*       OutStruct       TX_BITS  o      Structure of quantized parameters
*
**************************************************************************/

int FS1016Decode(
int     InArray[],
TX_BITS *OutStruct)
{
int     i, j=0;

/*  Get the LSFs from the array */
        for(i=0;i<ORDER;i++)    {
          OutStruct->lsf[i] = InArray[j++];
        }

/*  Put each subframe's parameters into the array */
        for(i=0;i<NUM_SF;i++)   {
          OutStruct->AdaptiveDelay[i] = InArray[j++];
          OutStruct->AdaptiveGain[i] = InArray[j++];
          OutStruct->StochasticIndex[i] = InArray[j++];
          OutStruct->StochasticGain[i] = InArray[j++];
        }

/*  Now put in the Bishnu bit */
        OutStruct->Bishnu = InArray[j++];

/*  Next the Hamming Code */
        OutStruct->Hamming = InArray[j++];

/*  And last the sync bit */
        OutStruct->Sync = InArray[j];


/*  Let the calling routine know how many parameters were filled */
        return(j+1);
}