/*====================================================================================
EVS Codec 3GPP TS26.443 Jun 30, 2015. Version CR 26.443-0006
====================================================================================*/
#include <math.h>
#include "options.h"
#include "cnst.h"
#include "rom_enc.h"
#include "prot.h"
#include "rom_com.h"
/*---------------------------------------------------------------------*
* Local functions
*---------------------------------------------------------------------*/
static short quant_1p_N1( const short pos, const short N );
static short quant_2p_2N1( const short pos1, const short pos2, const short N );
static short quant_3p_3N1( const short pos1, const short pos2, const short pos3, const short N );
static long quant_4p_4N( const short pos[], const short N );
static long quant_5p_5N( const short pos[], const short N );
static long quant_6p_6N_2( const short pos[], const short N );
static int pre_process( const float v[], short pos_vector[], int pos_vector_num[], int *pulse_pos_num);
static int fcb_encode_position( short pos_vector[], int n, int pos_num, int flag );
static int fcb_encode_class( int *buffer, int pulse_num, int pos_num );
static int fcb_encode_PI( const float v[], int pulse_num );
/*---------------------------------------------------------------------*
* ACELP_4t64()
*
* 20, 36, 44, 52, 64, 72, 88 bits algebraic codebook.
* 4 tracks x 16 positions per track = 64 samples.
*
* 20 bits --> 4 pulses in a frame of 64 samples.
* 36 bits --> 8 pulses in a frame of 64 samples.
* 44 bits 13 + 9 + 13 + 9 --> 10 pulses in a frame of 64 samples.
* 52 bits 13 + 13 + 13 + 13 --> 12 pulses in a frame of 64 samples.
* 64 bits 2 + 2 + 2 + 2 + 14 + 14 + 14 + 14 -->
* 16 pulses in a frame of 64 samples.
* 72 bits 10 + 2 + 10 + 2 + 10 + 14 + 10 + 14 -->
* 18 pulses in a frame of 64 samples.
* 88 bits 11 + 11 + 11 + 11 + 11 + 11 + 11 + 11 -->
* 24 pulses in a frame of 64 samples.
* All pulses can have two (2) possible amplitudes: +1 or -1.
* Each pulse can have sixteen (16) possible positions.
*---------------------------------------------------------------------*/
short acelp_4t64(
Encoder_State *st, /* i/o: encoder state structure */
float dn[], /* i : corr. between target and h[]. */
const float cn[], /* i : residual after long term prediction */
const float H[], /* i : impulse response of weighted synthesis filter */
float R[], /* i : autocorrelation values */
const short acelpautoc, /* i : autocorrealtion flag */
float code[], /* o : algebraic (fixed) codebook excitation */
float y[], /* o : filtered fixed codebook excitation */
short nbbits, /* i : number of bits per codebook */
const short cmpl_flag, /* i : coomplexity reduction flag */
const short Opt_AMR_WB /* i : flag indicating AMR-WB IO mode */
)
{
short i, k, index, track;
long L_index;
short ind[NPMAXPT*NB_TRACK_FCB_4T+32];
short saved_bits = 0;
PulseConfig config;
int indexing_indices[6], wordcnt, bitcnt;
/*-----------------------------------------------------------------*
* Configuration
*-----------------------------------------------------------------*/
switch (nbbits)
{
case 20: /* EVS/AMR-WB pulse indexing: 20 bits, 4 pulses, 4 tracks */
config.nbiter = 4; /* 4x12x16=768 loop */
config.alp = 2.0f;
config.nb_pulse = 4;
config.fixedpulses = 0;
config.nbpos[0] = 4;
config.nbpos[1] = 8;
break;
case 28: /* EVS pulse indexing: 28 bits, 6 pulses, 4 tracks */
config.nbiter = 4; /* 4x20x16=1280 loops */
config.alp = 1.0f; /* coeff for sign setting */
config.nb_pulse = 6;
config.fixedpulses = 0;
config.nbpos[0] = 6;
config.nbpos[1] = 6;
config.nbpos[2] = 8;
break;
case 36: /* EVS/AMR-WB pulse indexing: 36 bits, 8 pulses, 4 tracks */
config.nbiter = 4; /* 4x20x16=1280 loops */
config.alp = 1.0f; /* coeff for sign setting */
config.nb_pulse = 8;
config.fixedpulses = 2;
config.nbpos[0] = 4;
config.nbpos[1] = 8;
config.nbpos[2] = 8;
break;
case 43: /* EVS pulse indexing: 43 bits, 10 pulses, 4 tracks */
case 44: /* AMR-WB pulse indexing: 44 bits, 10 pulses, 4 tracks */
config.nbiter = 4; /* 4x26x16=1664 loops */
config.alp = 1.0f;
config.nb_pulse = 10;
config.fixedpulses = 2;
config.nbpos[0] = 4;
config.nbpos[1] = 6;
config.nbpos[2] = 8;
config.nbpos[3] = 8;
break;
case 50: /* EVS pulse indexing: 50 bits, 12 pulses, 4 tracks */
case 52: /* AMR-WB pulse indexing: 52 bits, 12 pulses, 4 tracks */
config.nbiter = 4; /* 4x26x16=1664 loops */
config.alp = 1.0f;
config.nb_pulse = 12;
config.fixedpulses = 4;
config.nbpos[0] = 4;
config.nbpos[1] = 6;
config.nbpos[2] = 8;
config.nbpos[3] = 8;
break;
case 62: /* EVS pulse indexing: 62 bits, 16 pulses, 4 tracks */
case 64: /* AMR-WB pulse indexing: 64 bits, 16 pulses, 4 tracks */
config.nbiter = 3; /* 3x36x16=1728 loops */
config.alp = 0.8F;
config.nb_pulse = 16;
config.fixedpulses = 4;
config.nbpos[0] = 4;
config.nbpos[1] = 4;
config.nbpos[2] = 6;
config.nbpos[3] = 6;
config.nbpos[4] = 8;
config.nbpos[5] = 8;
break;
case 72: /* AMR-WB pulse indexing: 72 bits, 18 pulses, 4 tracks */
config.nbiter = 3; /* 3x35x16=1680 loops */
config.alp = 0.75F;
config.nb_pulse = 18;
config.fixedpulses = 4;
config.nbpos[0] = 2;
config.nbpos[1] = 3;
config.nbpos[2] = 4;
config.nbpos[3] = 5;
config.nbpos[4] = 6;
config.nbpos[5] = 7;
config.nbpos[6] = 8;
break;
case 88: /* AMR-WB pulse indexing: 88 bits, 24 pulses, 4 tracks */
config.nbiter = 2; /* 2x53x16=1696 loop */
config.alp = 0.5f;
config.nb_pulse = 24;
config.fixedpulses = 4;
config.nbpos[0] = 2;
config.nbpos[1] = 2;
config.nbpos[2] = 3;
config.nbpos[3] = 4;
config.nbpos[4] = 5;
config.nbpos[5] = 6;
config.nbpos[6] = 7;
config.nbpos[7] = 8;
config.nbpos[8] = 8;
config.nbpos[9] = 8;
break;
case 87: /* EVS pulse indexing: 87 bits, 26 pulses, 4 tracks */
config.nbiter = 1;
config.alp = 0.5F;
config.nb_pulse = 26;
config.fixedpulses = 4;
config.nbpos[0] = 4;
config.nbpos[1] = 6;
config.nbpos[2] = 6;
config.nbpos[3] = 8;
config.nbpos[4] = 8;
config.nbpos[5] = 8;
config.nbpos[6] = 8;
config.nbpos[7] = 8;
config.nbpos[8] = 8;
config.nbpos[9] = 8;
config.nbpos[10] = 8;
break;
}
/* reduce the number of iterations as a compromise between the performance and complexity */
if( cmpl_flag > 0 )
{
config.nbiter = cmpl_flag;
}
config.codetrackpos = TRACKPOS_FIXED_FIRST;
config.bits = nbbits;
/*-----------------------------------------------------------------*
* Search
*-----------------------------------------------------------------*/
if( acelpautoc )
{
E_ACELP_4tsearchx( dn, cn, R, code, &config, ind );
/* Generate weighted code */
set_f( y, 0.0f, L_SUBFR );
for( i=0; i<L_SUBFR; i++ )
{
/* Code is sparse, so check which samples are non-zero */
if( code[i] != 0 )
{
for( k=0; k<L_SUBFR-i; k++ )
{
y[i+k] += code[i] * H[k];
}
}
}
}
else
{
E_ACELP_4tsearch( dn, cn, H, code, &config, ind, y );
}
/*-----------------------------------------------------------------*
* Indexing
*-----------------------------------------------------------------*/
if( !Opt_AMR_WB )
{
/* EVS pulse indexing */
saved_bits = E_ACELP_indexing( code, config, NB_TRACK_FCB_4T, indexing_indices );
saved_bits = 0;
wordcnt = nbbits >> 4;
bitcnt = nbbits & 15;
for ( i = 0; i < wordcnt; i++ )
{
push_indice( st, IND_ALG_CDBK_4T64, indexing_indices[i], 16 );
}
if ( bitcnt )
{
push_indice( st, IND_ALG_CDBK_4T64, indexing_indices[i], bitcnt );
}
}
else
{
/* AMR-WB pulse indexing */
if (nbbits == 20)
{
for (track = 0; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
index = quant_1p_N1(ind[k], 4);
push_indice( st, IND_ALG_CDBK_4T64, index, 5 );
}
}
else if (nbbits == 36)
{
for (track = 0; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
index = quant_2p_2N1(ind[k], ind[k+1], 4);
push_indice( st, IND_ALG_CDBK_4T64, index, 9 );
}
}
else if (nbbits == 44)
{
for (track = 0; track < (NB_TRACK_FCB_4T - 2); track++)
{
k = track * NPMAXPT;
index = quant_3p_3N1(ind[k], ind[k+1], ind[k+2], 4);
push_indice( st, IND_ALG_CDBK_4T64, index, 13 );
}
for (track = 2; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
index = quant_2p_2N1(ind[k], ind[k+1], 4);
push_indice( st, IND_ALG_CDBK_4T64, index, 9 );
}
}
else if (nbbits == 52)
{
for (track = 0; track < NB_TRACK_FCB_4T; track++)
{
k = track*NPMAXPT;
index = quant_3p_3N1(ind[k], ind[k+1], ind[k+2], 4);
push_indice( st, IND_ALG_CDBK_4T64, index, 13 );
}
}
else if (nbbits == 64)
{
for (track = 0; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
L_index = quant_4p_4N(&ind[k], 4);
index = ((L_index >> 14) & 3);
push_indice( st, IND_ALG_CDBK_4T64_1, index, 2 );
}
for (track = 0; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
L_index = quant_4p_4N(&ind[k], 4);
index = (L_index & 0x3FFF);
push_indice( st, IND_ALG_CDBK_4T64_2, index, 14 );
}
}
else if (nbbits == 72)
{
for (track=0; track< (NB_TRACK_FCB_4T - 2); track++)
{
k = track * NPMAXPT;
L_index = quant_5p_5N(&ind[k], 4);
index = ((L_index >> 10) & 0x03FF);
push_indice( st, IND_ALG_CDBK_4T64_1, index, 10 );
}
for (track = 2; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
L_index = quant_4p_4N(&ind[k], 4);
index = ((L_index >> 14) & 3);
push_indice( st, IND_ALG_CDBK_4T64_1, index, 2 );
}
for (track=0; track< (NB_TRACK_FCB_4T - 2); track++)
{
k = track * NPMAXPT;
L_index = quant_5p_5N(&ind[k], 4);
index = (L_index & 0x03FF);
push_indice( st, IND_ALG_CDBK_4T64_2, index, 10 );
}
for (track = 2; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
L_index = quant_4p_4N(&ind[k], 4);
index = (L_index & 0x3FFF);
push_indice( st, IND_ALG_CDBK_4T64_2, index, 14 );
}
}
else if (nbbits == 88)
{
for (track = 0; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
L_index = quant_6p_6N_2(&ind[k], 4);
index = ((L_index >> 11) & 0x07FF);
push_indice( st, IND_ALG_CDBK_4T64_1, index, 11 );
}
for (track = 0; track < NB_TRACK_FCB_4T; track++)
{
k = track * NPMAXPT;
L_index = quant_6p_6N_2(&ind[k], 4);
index = (L_index & 0x07FF);
push_indice( st, IND_ALG_CDBK_4T64_2, index, 11 );
}
}
}
return saved_bits;
}
/*---------------------------------------------------------------------*
* Quantization of 1 pulse with N+1 bits: *
*---------------------------------------------------------------------*/
static short quant_1p_N1( /* o: return N+1 bits */
const short pos, /* i: position of the pulse */
const short N /* i: number of bits for position */
)
{
short mask, index;
mask = ((1<<N)-1);
index = (pos & mask);
if ((pos & NB_POS_FCB_4T) != 0)
{
index += 1 << N;
}
return index;
}
/*---------------------------------------------------------------------*
* Quantization of 2 pulses with 2*N+1 bits: *
*---------------------------------------------------------------------*/
static short quant_2p_2N1( /* o: return (2*N)+1 bits */
const short pos1, /* i: position of the pulse 1 */
const short pos2, /* i: position of the pulse 2 */
const short N /* i: number of bits for position */
)
{
short mask, index;
mask = ((1<<N)-1);
/*-----------------------------------------------------------------*
* sign of 1st pulse == sign of 2nd pulse
*-----------------------------------------------------------------*/
if (((pos2 ^ pos1) & NB_POS_FCB_4T) == 0)
{
if ((pos1 - pos2) <= 0)
{
index = ((pos1 & mask) << N) + (pos2 & mask);
}
else
{
index = ((pos2 & mask) << N) + (pos1 & mask);
}
if ((pos1 & NB_POS_FCB_4T) != 0)
{
index += 1 << (2*N);
}
}
else
{
/*-----------------------------------------------------------------*
* sign of 1st pulse != sign of 2nd pulse
*-----------------------------------------------------------------*/
if (((pos1 & mask) - (pos2 & mask)) <= 0)
{
index = ((pos2 & mask) << N) + (pos1 & mask);
if ((pos2 & NB_POS_FCB_4T) != 0)
{
index += 1 << (2*N);
}
}
else
{
index = ((pos1 & mask) << N) + (pos2 & mask);
if ((pos1 & NB_POS_FCB_4T) != 0)
{
index += 1 << (2*N);
}
}
}
return index;
}
/*---------------------------------------------------------------------*
* Quantization of 3 pulses with 3*N+1 bits: *
*---------------------------------------------------------------------*/
static short quant_3p_3N1( /* o: return (3*N)+1 bits */
const short pos1, /* i: position of the pulse 1 */
const short pos2, /* i: position of the pulse 2 */
const short pos3, /* i: position of the pulse 3 */
const short N /* i: number of bits for position */
)
{
short index, nb_pos;
nb_pos = (1 << (N-1));
/* Quantization of 3 pulses with 3*N+1 bits */
if (((pos1 ^ pos2) & nb_pos) == 0)
{
index = quant_2p_2N1(pos1, pos2, (N - 1));
index += (pos1 & nb_pos) << N;
index += quant_1p_N1(pos3, N) << (2 * N);
}
else if (((pos1 ^ pos3) & nb_pos) == 0)
{
index = quant_2p_2N1(pos1, pos3, (N - 1));
index += (pos1 & nb_pos) << N;
index += quant_1p_N1(pos2, N) << (2 * N);
}
else
{
index = quant_2p_2N1(pos2, pos3, (N - 1));
index += (pos2 & nb_pos) << N;
index += quant_1p_N1(pos1, N) << (2 * N);
}
return index;
}
/*---------------------------------------------------------------------*
* Quantization of 4 pulses with 4*N+1 bits: *
*---------------------------------------------------------------------*/
static long quant_4p_4N1( /* o: return (4*N)+1 bits */
const short pos1, /* i: position of the pulse 1 */
const short pos2, /* i: position of the pulse 2 */
const short pos3, /* i: position of the pulse 3 */
const short pos4, /* i: position of the pulse 4 */
const short N /* i: number of bits for position */
)
{
long index, nb_pos;
nb_pos = (1 << (N-1));
/* Quantization of 4 pulses with 4*N+1 bits */
if (((pos1 ^ pos2) & nb_pos) == 0)
{
index = quant_2p_2N1(pos1, pos2, (N - 1));
index += (pos1 & nb_pos) << N;
index += quant_2p_2N1(pos3, pos4, N) << (2 * N);
}
else if (((pos1 ^ pos3) & nb_pos) == 0)
{
index = quant_2p_2N1(pos1, pos3, (N - 1));
index += (pos1 & nb_pos) << N;
index += quant_2p_2N1(pos2, pos4, N) << (2 * N);
}
else
{
index = quant_2p_2N1(pos2, pos3, (N - 1));
index += (pos2 & nb_pos) << N;
index += quant_2p_2N1(pos1, pos4, N) << (2 * N);
}
return (index);
}
/*---------------------------------------------------------------------*
* Quantization of 4 pulses with 4*N bits: *
*---------------------------------------------------------------------*/
static long quant_4p_4N( /* o: return 4*N bits */
const short pos[], /* i: position of the pulse 1..4 */
const short N /* i: number of bits for position */
)
{
short i, j, k, n_1;
short posA[4], posB[4];
long nb_pos, index = 0;
n_1 = N - 1;
nb_pos = (1 << n_1);
i = 0;
j = 0;
for (k = 0; k < 4; k++)
{
if ((pos[k] & nb_pos) == 0)
{
posA[i++] = pos[k];
}
else
{
posB[j++] = pos[k];
}
}
switch (i)
{
case 0:
index = 1 << ((4 * N) - 3);
index += quant_4p_4N1(posB[0], posB[1], posB[2], posB[3], n_1);
break;
case 1:
index = quant_1p_N1(posA[0], n_1) << (( 3 * n_1) + 1);
index += quant_3p_3N1(posB[0], posB[1], posB[2], n_1);
break;
case 2:
index = quant_2p_2N1(posA[0], posA[1], n_1) << (( 2 * n_1) + 1);
index += quant_2p_2N1(posB[0], posB[1], n_1);
break;
case 3:
index = quant_3p_3N1(posA[0], posA[1], posA[2], n_1) << N;
index += quant_1p_N1(posB[0], n_1);
break;
case 4:
index = quant_4p_4N1(posA[0], posA[1], posA[2], posA[3], n_1);
break;
}
index += (i & 3) << ((4 * N) - 2);
return (index);
}
/*---------------------------------------------------------------------*
* Quantization of 5 pulses with 5*N bits: *
*---------------------------------------------------------------------*/
static long quant_5p_5N( /* o: return 5*N bits */
const short pos[], /* i: position of the pulse 1..5 */
const short N /* i: number of bits for position */
)
{
short i, j, k, n_1, nb_pos;
short posA[5], posB[5];
long index = 0;
n_1 = N-1;
nb_pos = (1 << n_1);
i = 0;
j = 0;
for (k = 0; k < 5; k++)
{
if ((pos[k] & nb_pos) == 0)
{
posA[i++] = pos[k];
}
else
{
posB[j++] = pos[k];
}
}
switch (i)
{
case 0:
index = 1 << ((5 * N) - 1);
index += quant_3p_3N1(posB[0], posB[1], posB[2], n_1) << ((2 * N) + 1);
index += quant_2p_2N1(posB[3], posB[4], N);
break;
case 1:
index = 1 << ((5 * N) - 1);
index += quant_3p_3N1(posB[0], posB[1], posB[2], n_1) << ((2 * N) + 1);
index += quant_2p_2N1(posB[3], posA[0], N);
break;
case 2:
index = 1 << ((5 * N) - 1);
index += quant_3p_3N1(posB[0], posB[1], posB[2], n_1) << ((2 * N) + 1);
index += quant_2p_2N1(posA[0], posA[1], N);
break;
case 3:
index = quant_3p_3N1(posA[0], posA[1], posA[2], n_1) << ((2 * N) + 1);
index += quant_2p_2N1(posB[0], posB[1], N);
break;
case 4:
index = quant_3p_3N1(posA[0], posA[1], posA[2], n_1) << ((2 * N) + 1);
index += quant_2p_2N1(posA[3], posB[0], N);
break;
case 5:
index = quant_3p_3N1(posA[0], posA[1], posA[2], n_1) << ((2 * N) + 1);
index += quant_2p_2N1(posA[3], posA[4], N);
break;
}
return (index);
}
/*---------------------------------------------------------------------*
* Quantization of 6 pulses with 6*N-2 bits: *
*---------------------------------------------------------------------*/
static long quant_6p_6N_2(/* o: return 6*N-2 bits */
const short pos[], /* i: position of the pulse 1..6 */
const short N /* i: number of bits for position */
)
{
short i, j, k, n_1;
short posA[6], posB[6];
long nb_pos, index = 0;
n_1 = N - 1;
nb_pos = 1 << n_1;
i = 0;
j = 0;
for (k = 0; k < 6; k++)
{
if ((pos[k] & nb_pos) == 0)
{
posA[i++] = pos[k];
}
else
{
posB[j++] = pos[k];
}
}
switch (i)
{
case 0:
index = 1 << ((6 * N) - 5);
index += quant_5p_5N(posB, n_1) << N;
index += quant_1p_N1(posB[5], n_1);
break;
case 1:
index = 1 << ((6 * N) - 5);
index += quant_5p_5N(posB, n_1) << N;
index += quant_1p_N1(posA[0], n_1);
break;
case 2:
index = 1 << ((6 * N) - 5);
index += quant_4p_4N(posB, n_1) << ((2 * n_1) + 1);
index += quant_2p_2N1(posA[0], posA[1], n_1);
break;
case 3:
index = quant_3p_3N1(posA[0], posA[1], posA[2], n_1) << ((3 * n_1) + 1);
index += quant_3p_3N1(posB[0], posB[1], posB[2], n_1);
break;
case 4:
i = 2;
index = quant_4p_4N(posA, n_1) << ((2 * n_1) + 1);
index += quant_2p_2N1(posB[0], posB[1], n_1);
break;
case 5:
i = 1;
index = quant_5p_5N(posA, n_1) << N;
index += quant_1p_N1(posB[0], n_1);
break;
case 6:
i = 0;
index = quant_5p_5N(posA, n_1) << N;
index += quant_1p_N1(posA[5], n_1);
break;
}
index += (i & 3) << ((6 * N) - 4);
return (index);
}
/*---------------------------------------------------------------------*
*order the pulse position *
*---------------------------------------------------------------------*/
static int pre_process( /* o: return sign value of pulse on a track */
const float v[], /* i: the pulse vector */
short pos_vector[], /* o: position of the pulse on a track */
int pos_vector_num[], /* o: the pulse number on the position which have pulse */
int *pulse_pos_num /* i: the number of position which have pulse */
)
{
int j,k;
int sign;
sign = 0;
j = 0;
for (k=0; k<64; k+=4)
{
if (v[k])
{
pos_vector[j] = k>>2;
pos_vector_num[j] = fabs(v[k]);
if (v[k]>0)
sign = sign << 1;
else
sign = ( sign << 1 ) + 1;
j++;
}
}
*pulse_pos_num = j;
return sign;
}
/*---------------------------------------------------------------------*
*encode the position *
*---------------------------------------------------------------------*/
static int fcb_encode_position( /* o: return index of the positions which have pulse*/
short pos_vector[], /* i: position of the pulse on a track */
int n,
int pos_num, /* i: the number of position which have pulse */
int flag
)
{
int i;
int mmm1;
int temp2;
mmm1 = PI_select_table[n][pos_num] - 1;
temp2 = pos_num;
if (flag) /* no decrease */
{
for (i=0; i<pos_num; i++)
{
mmm1 -= PI_select_table[n-pos_vector[i]-1][temp2--];
}
}
else
{
for (i=0; i<pos_num; i++)
{
mmm1 -= PI_select_table[n-pos_vector[i]-1][temp2--];
n--;
}
}
return mmm1;
}
/*---------------------------------------------------------------------*
*encode class for 3p 4p 5p 6p/track *
*---------------------------------------------------------------------*/
static int fcb_encode_cl(/* o: class index of the pulse on a track */
int buffer[], /* i: pulses on a track */
int pulse_num, /* i: pulses number on a track */
int pos_num /* i: number of the position which have pulse */
)
{
int i,k;
int temp1,temp2;
temp1 = pos_num + pulse_num - 1;
temp2 = pulse_num;
k = PI_select_table[temp1][pulse_num] - 1;
temp1 --;
for (i=0; i<pulse_num; i++)
{
k -= PI_select_table[temp1-buffer[i]][temp2--];
temp1--;
}
return k;
}
/*---------------------------------------------------------------------*
*encode the class and compute class offset *
*---------------------------------------------------------------------*/
static int fcb_encode_class(/* o: class offset */
int sector_6p_num[], /* i: position which have pulse on a track */
int pulse_num, /* i: pulse number on a track */
int pulse_pos_num /* i: number of position which have pulse on a track */
)
{
int i,j,k;
int mn9_offet;
int vector_class[6];
int *vector_class_ptr;
mn9_offet = 0;
if ( pulse_pos_num < pulse_num )
{
vector_class_ptr = vector_class;
for (i=0; i<pulse_pos_num; i++)
{
for (j=0; j<(sector_6p_num[i]-1); j++)
{
*vector_class_ptr++ = i ;
}
}
k = fcb_encode_cl(vector_class,pulse_num-pulse_pos_num,pulse_pos_num);
mn9_offet = PI_factor[pulse_pos_num] * k ;
}
return mn9_offet;
}
/*---------------------------------------------------------------------*
*encode fcb pulse index *
*---------------------------------------------------------------------*/
static int fcb_encode_PI( /* o: return index of the pulse on a track */
const float v[], /* i: the pulse vector */
int pulse_num /* i: number of the pulse on a track */
)
{
short vector_p[7];
int pulse_pos_num;
int vector_p_num[7];
int code_index;
int sign;
/*order the pulse position*/
sign = pre_process(v, vector_p, vector_p_num, &pulse_pos_num);
/*encode the position*/
code_index = fcb_encode_position(vector_p,16,pulse_pos_num,1);
/*encode the class and compute class offset*/
code_index += fcb_encode_class(vector_p_num,pulse_num,pulse_pos_num);
code_index = PI_offset[pulse_num][pulse_num + 1 - pulse_pos_num] + ( code_index << pulse_pos_num ) + sign;
return code_index;
}
/*--------------------------------------------------------------------------*
* E_ACELP_code43bit
*
* Fixed bit-length arithmetic coding of pulses
* v - (input) pulse vector
* s - (output) encoded state
* n - (output) range of possible states (0...n-1)
* p - (output) number of pulses found
* len - (input) length of pulse vector
* trackstep - (input) step between tracks
*--------------------------------------------------------------------------*/
short E_ACELP_code43bit(const float code[], long unsigned *ps, int *p, unsigned short idxs[])
{
int j,k,track;
int ind[32];
int tmp;
int joint_index;
int joint_offset = 3611648; /*offset for 3 pulses per track*/
short saved_bits = 0;
for (track = 0; track< 2; track++)
{
k = track * NPMAXPT;
ps[track] = fcb_encode_PI(code+track,3);
p[track] = 3;
}
for (track = 2; track < NB_TRACK_FCB_4T; track++)
{
j = track * NPMAXPT;
for (k=track; k<64; k+=4)
{
if (code[k])
{
tmp = k>>2;
if (code[k]<0)
{
tmp += 16;
}
if (fabs(code[k])>1)
{
ind[j] = tmp;
ind[j+1] = tmp;
break;
}
else
{
ind[j] = tmp;
j++;
}
}
}
k = track * NPMAXPT;
ps[track] = quant_2p_2N1(ind[k], ind[k+1], 4);
p[track] = 2;
}
joint_index = ps[0]*5472 + ps[1];
if (joint_index >= joint_offset)
{
joint_index += joint_offset;
}
else
{
saved_bits += 1;
}
idxs[0] = ( ( ps[2] << 9 ) + ps[3] ) & 0xffff;
idxs[1] = ( ( joint_index << 2 ) + ( ps[2] >> 7 ) ) & 0xffff;
idxs[2] = joint_index >> 14;
return saved_bits;
}