codeparm.c

手机加密通话软件

/* Copyright 2001,2002,2003 NAH6
 * All Rights Reserved
 *
 * Parts Copyright DoD, Parts Copyright Starium
 *
 */
#include "main.h"
#ifdef FLOATING_POINT
#error floating_point
#endif
#include "acb_code.h"
#include "codeparm.h"
#include "error.h"
#include "scb_code.h"
#include "code_lsf.h"

#define NPARAMS 10+(4*4)+3

//int BitAllocs[NPARAMS] = {
//      3, 4, 4, 4, 4, 3, 3, 3, 3, 3,   /* For LSFs */
//      8, 6, 8, 6,                     /* For ACB Delay */
//      5, 5, 5, 5,                     /* For ACB Gain */
//      9, 9, 9, 9,                     /* For SCB Index */
//      5, 5, 5, 5,                     /* For SCB Gain */
//      1,                              /* For Bishnu Bit */
//      1                               /* For Sync Bit */
//};


/*  FS1016 compatible bit allocations */
int BitAllocs[NPARAMS] = {
        3, 4, 4, 4, 4, 3, 3, 3, 3, 3,   /* For LSFs */
        8, 5, 9, 5,                     /* For first subframe parameters */
        6, 5, 9, 5,                     /* For second subframe parameters */
        8, 5, 9, 5,                     /* For third subframe parameters */
        6, 5, 9, 5,                     /* For fourth subframe parameters */
        1,                              /* For Bishnu Bit */
        4,                              /* For Hamming bits */
        1                               /* For Sync Bit */
};

STATIC void Encode(
TX_PARAM        parameters,
TX_BITS         *bits);

STATIC void Decode(
TX_BITS         bits,
int             Assurance,
int             SmoothFlag,
TX_PARAM        *parameters) ;

STATIC void Pack(
int             NParams,
int             Params[],
int             BitAllocs[],
int             *NumPacked,
int             Channel[]);

STATIC void Unpack(
int             NParams,
int             BitAllocs[],
int             Channel[],
int             *NumUnpacked,
int             Params[]);

STATIC void ACBDelayEncode(fxpt_16 Udelay, int *Qdelay);

STATIC void ACBDelayDecode(int Qdelay, fxpt_16 *Udelay);

STATIC int FS1016Encode(TX_BITS InStruct, int OutArray[]);

STATIC int FS1016Decode(int InArray[], TX_BITS *OutStruct);




/**************************************************************************
*                                                                         *
* ROUTINE
*               EncodeParameters
*
* FUNCTION
*               Encode and Pack CELP parameters
* SYNOPSIS
*               EncodeParameters(parameters, bit_len, error_parms, edac,
*                                       frame_num, channel)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       parameters      TX_PARAM i      Frame of CELP parameters
*       bit_len         int      i      Number of bits to encode
*       error_parms     char     i      Name of error parameter file
*       edac            int      i      EDAC flag
*       frame_num       int      i      Frame number
*       channel         int      o      Frame of bits from analysis
*
**************************************************************************/

#include "bitperm.h"

void EncodeParameters(
TX_PARAM        parameters,
int             edac,
uint8           wire_bits[CELP_WIREREP_BYTES])
{
TX_BITS         bits;
int             BitChannel[CELP_WIREREP_BITS];
int             NumPacked;
int             FSParms[NPARAMS];
int             i;

FXPT_PUSHSTATE("EncodeParameters", -1.0, -1.0);
/*  Convert TX parameters to fixed point values that can be transmitted */
        Encode(parameters, &bits);

/*  Put these parameters into FS 1016 compatible form */
        if (FS1016Encode(bits, FSParms) != NPARAMS)
          CELP_PRINTF(("*** Problem Encoding to FS1016 ***\n"));

/*  Pack these values into a binary stream */
        Pack(NPARAMS, FSParms, BitAllocs, &NumPacked, BitChannel);

/*  Perform error protection coding */
          ErrorEncode(BitChannel, edac);

/*  Permute the stream if no EDAC */
        for (i = 0; i < CELP_BYTES; i++)        {
          wire_bits[i] =
            BitChannel[ BitPermute[i * 8 + 0] - 1 ] << 0 |
            BitChannel[ BitPermute[i * 8 + 1] - 1 ] << 1 |
            BitChannel[ BitPermute[i * 8 + 2] - 1 ] << 2 |
            BitChannel[ BitPermute[i * 8 + 3] - 1 ] << 3 |
            BitChannel[ BitPermute[i * 8 + 4] - 1 ] << 4 |
            BitChannel[ BitPermute[i * 8 + 5] - 1 ] << 5 |
            BitChannel[ BitPermute[i * 8 + 6] - 1 ] << 6 |
            BitChannel[ BitPermute[i * 8 + 7] - 1 ] << 7 ;
        }
FXPT_POPSTATE();
}


/**************************************************************************
*                                                                         *
* ROUTINE
*               DecodeParameters
*
* FUNCTION
*               Decode and Unpack CELP parameters
* SYNOPSIS
*               DecodeParameters(bits, num_bits, error_parms, edac,
                        FrameNum, SmoothFlag, parameters)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       channel         int      i      Frame of bits from channel
*       num_bits        int      i      Number of bits in channel
*       error_parms     char     i      Name of error parameter file
*       edac            int      i      EDAC flag
*       FrameNum        int      i      Frame Number
*       SmoothFlag      int      i      User's smoothing preference
*       parameters      TX_PARAM o      Frame of CELP parameters
*
**************************************************************************/

void DecodeParameters(
const uint8     wire_bits[CELP_WIREREP_BYTES],
int             edac,
int             SmoothFlag,
TX_PARAM        *parameters)
{
TX_BITS         bits;
int             BitChannel[CELP_WIREREP_BITS];
int             NumUnpacked;
int             FSParms[NPARAMS];
int             i;
int             Assurance;

/*  Unpermute the stream  */
        for (i = 0; i < CELP_BYTES; i++) {
          BitChannel[BitPermute[i * 8 + 0]-1] = (wire_bits[i] >> 0) & 0x1;
          BitChannel[BitPermute[i * 8 + 1]-1] = (wire_bits[i] >> 1) & 0x1;
          BitChannel[BitPermute[i * 8 + 2]-1] = (wire_bits[i] >> 2) & 0x1;
          BitChannel[BitPermute[i * 8 + 3]-1] = (wire_bits[i] >> 3) & 0x1;
          BitChannel[BitPermute[i * 8 + 4]-1] = (wire_bits[i] >> 4) & 0x1;
          BitChannel[BitPermute[i * 8 + 5]-1] = (wire_bits[i] >> 5) & 0x1;
          BitChannel[BitPermute[i * 8 + 6]-1] = (wire_bits[i] >> 6) & 0x1;
          BitChannel[BitPermute[i * 8 + 7]-1] = (wire_bits[i] >> 7) & 0x1;
        }

/*  Check for errors and correct */
        ErrorDecode(BitChannel, edac, &Assurance);

/*  Unpack the corrected binary stream */
        Unpack(NPARAMS, BitAllocs, BitChannel, &NumUnpacked, FSParms);

/*  Translate from FS1016 compatible mode */
        if (FS1016Decode(FSParms, &bits) != NPARAMS)
          CELP_PRINTF(("*** Problem Decoding from FS1016 ***\n"));

/*  Decode RX bits into parameters to be synthesized */
        Decode(bits, Assurance, SmoothFlag, parameters);

}

/**************************************************************************
*                                                                         *
* ROUTINE
*               Encode
*
* FUNCTION
*               Encode CELP parameters
* SYNOPSIS
*               Encode(parameters, bits)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       parameters      TX_PARAM i      Frame of CELP parameters
*       bits            TX_BITS  o      Frame of bits from analysis
*
**************************************************************************/

void Encode(
TX_PARAM        parameters,
TX_BITS         *bits)
{
int             sf;
static int      sync=0;
fxpt_16         qlsf[ORDER];

FXPT_PUSHSTATE("Encode", -1.0, -1.0);
/*  Convert LSFs to int representation */
        QuanLSF(parameters.lsf, qlsf, bits->lsf);

        for(sf=0; sf < NUM_SF; sf++)    {
/*  Convert ACB gain to int representation */
          ACBGainEncode(parameters.AdaptiveGain[sf], &bits->AdaptiveGain[sf]);

/*  Convert ACB delay to int representation */
          ACBDelayEncode(parameters.AdaptiveDelay[sf],
                &bits->AdaptiveDelay[sf]);

/*  Convert SCB gain to int representation */
          SCBGainEncode(parameters.StochasticGain[sf], &bits->StochasticGain[sf]);

/*  Convert SCB index to int representation */
          bits->StochasticIndex[sf] = parameters.StochasticIndex[sf]-1;
        }

/*  Encode Bishnu bit */
        bits->Bishnu = 0;

/*  Encode sync bit */
        bits->Sync = sync;

/*  Update sync bit */
        sync = (sync == 0) ? 1 : 0;

FXPT_POPSTATE();
}


/**************************************************************************
*                                                                         *
* ROUTINE
*               Decode
*
* FUNCTION
*               Decode CELP parameters
* SYNOPSIS
*               Decode(bits, Assurance, FrameNum, SmoothFlag, parameters)
*
*   formal
*
*                       data    I/O
*       name            type    type    function
*       -------------------------------------------------------------------
*       bits            TX_BITS  i      Frame of bits from analysis
*       Assurance       int      i      Assurance value from EDAC
*       FrameNum        int      i      Frame number
*       SmoothFlag      int      i      User's smoothing preference
*       parameters      TX_PARAM o      Frame of CELP parameters
*
**************************************************************************/

void Decode(
TX_BITS         bits,
int             Assurance,
int             SmoothFlag,
TX_PARAM        *parameters)
{
int     sf;

/*  Convert LSFs from int representation */
        UnquanLSF(bits.lsf, ORDER, parameters->lsf);

        for(sf=0; sf<NUM_SF; sf++)      {
/*  Convert ACB gain from int representation */
          ACBGainDecode(bits.AdaptiveGain[sf], &parameters->AdaptiveGain[sf]);

/*  Convert ACB delay from int representation */
          ACBDelayDecode(bits.AdaptiveDelay[sf], &parameters->AdaptiveDelay[sf]);

/*  Convert SCB gain from int representation */
          SCBGainDecode(bits.StochasticGain[sf], &parameters->StochasticGain[sf]);

/*  Convert SCB index from int representation */
          parameters->StochasticIndex[sf] = bits.StochasticIndex[sf]+1;

#ifdef FLOATING_POINT
/*  Smooth if necessary and user reqests it */
          if (SmoothFlag)       {
            Smooth(Assurance, FrameNum, sf, parameters);
          }
#endif


        }