You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
163 lines
10 KiB
163 lines
10 KiB
/*
|
|
utils.h
|
|
|
|
Copyright (C) 2011 Belledonne Communications, Grenoble, France
|
|
Author : Johan Pascal
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
#ifndef UTILS_H
|
|
#define UTILS_H
|
|
|
|
/*****************************************************************************/
|
|
/* insertionSort : sort an array in growing order using insertion algorithm */
|
|
/* parameters : */
|
|
/* -(i/o) x: the array to be sorted */
|
|
/* -(i) length: the array length */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void insertionSort(word16_t x[], int length);
|
|
|
|
/*****************************************************************************/
|
|
/* computeParity : compute parity for pitch delay adaptative codebook index */
|
|
/* XOR of the 6 MSB (pitchDelay on 8 bits) */
|
|
/* parameters : */
|
|
/* -(i) adaptativeCodebookIndex: the pitch delay on 8 bits */
|
|
/* return value : */
|
|
/* the parity bit */
|
|
/* */
|
|
/*****************************************************************************/
|
|
uint16_t computeParity(uint16_t adaptativeCodebookIndex);
|
|
|
|
/*****************************************************************************/
|
|
/* rearrangeCoefficients: rearrange coefficients according to spec 3.2.4 */
|
|
/* Have a minimum distance of J beetwen two consecutive coefficients */
|
|
/* parameters: */
|
|
/* -(i/o) qLSP: 10 ordered coefficients in Q13 replaced by new values */
|
|
/* if needed */
|
|
/* -(i) J: minimum distance between coefficients in Q0.13 (10 or 5) */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void rearrangeCoefficients(word16_t qLSP[], word16_t J);
|
|
|
|
/*****************************************************************************/
|
|
/* synthesisFilter : compute 1/[A(z)] using the following algorithm */
|
|
/* filteredSignal[n] = inputSignal[n] */
|
|
/* - Sum(i=1..10)filterCoefficients[i]*filteredSignal[n-i] */
|
|
/* for n in [0, L_SUBFRAME[ */
|
|
/* parameters: */
|
|
/* -(i) inputSignal: 40 values in Q0 */
|
|
/* -(i) filterCoefficients: 10 coefficients in Q12 */
|
|
/* -(i/o) filteredSignal: 50 values in Q0 accessed in ranges [-10,-1] */
|
|
/* as input and [0, 39] as output. */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void synthesisFilter(word16_t inputSignal[], word16_t filterCoefficients[], word16_t filteredSignal[]);
|
|
|
|
/*****************************************************************************/
|
|
/* correlateVectors : compute the correlations between two vectors of */
|
|
/* L_SUBFRAME length: c[i] = Sum(x[j]*y[j-i]) j in [i..L_SUBFRAME] */
|
|
/* parameters: */
|
|
/* -(i) x : L_SUBFRAME length input vector on 16 bits */
|
|
/* -(i) y : L_SUBFRAME length input vector on 16 bits */
|
|
/* -(o) c : L_SUBFRAME length output vector on 32 bits */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void correlateVectors (word16_t x[], word16_t y[], word32_t c[]);
|
|
|
|
/*****************************************************************************/
|
|
/* countLeadingZeros : return the number of zero heading the argument */
|
|
/* MSB is excluded as considered sign bit. */
|
|
/* May be replaced by one asm instruction. */
|
|
/* parameters : */
|
|
/* -(i) x : 32 bits values >= 0 (no checking done by this function) */
|
|
/* return value : */
|
|
/* - number of heading zeros(MSB excluded. Ex: 0x0080 00000 returns 7) */
|
|
/* */
|
|
/*****************************************************************************/
|
|
static inline uint16_t countLeadingZeros(word32_t x)
|
|
{
|
|
if (x==0) return 31;
|
|
uint16_t leadingZeros = 0;
|
|
while (x<(word32_t)0x40000000) {
|
|
leadingZeros++;
|
|
x <<=1;
|
|
}
|
|
return leadingZeros;
|
|
}
|
|
|
|
/*** gain related functions ***/
|
|
/*****************************************************************************/
|
|
/* MACodeGainPrediction : spec 3.9.1 */
|
|
/* parameters: */
|
|
/* -(i) previousGainPredictionError: qU(m) in eq69 4 values in Q10 */
|
|
/* -(i) fixedCodebookVector: the current subframe fixed codebook vector */
|
|
/* 40 values in Q1.13 */
|
|
/* return value : */
|
|
/* - predicted Fixed Codebook gain on 32 bits in Q16 range [3, 1830] */
|
|
/* */
|
|
/*****************************************************************************/
|
|
word32_t MACodeGainPrediction(word16_t *previousGainPredictionError, word16_t *fixedCodebookVector);
|
|
|
|
/*****************************************************************************/
|
|
/* computeGainPredictionError : apply eq72 to compute current fixed Codebook */
|
|
/* gain prediction error and store the result in the adhoc array */
|
|
/* parameters : */
|
|
/* -(i) fixedCodebookGainCorrectionFactor: gamma in eq72 in Q3.12 */
|
|
/* -(i/o) previousGainPredictionError: array to be updated in Q10 */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void computeGainPredictionError(word16_t fixedCodebookGainCorrectionFactor, word16_t *previousGainPredictionError);
|
|
|
|
/*** bitStream to parameters Array conversions functions ***/
|
|
/* Note: these functions are in utils.c because used by test source code too */
|
|
|
|
/*****************************************************************************/
|
|
/* parametersArray2BitStream : convert array of parameters to bitStream */
|
|
/* according to spec 4 - Table 8 and following mapping of values */
|
|
/* 0 -> L0 (1 bit) */
|
|
/* 1 -> L1 (7 bits) */
|
|
/* 2 -> L2 (5 bits) */
|
|
/* 3 -> L3 (5 bits) */
|
|
/* 4 -> P1 (8 bit) */
|
|
/* 5 -> P0 (1 bits) */
|
|
/* 6 -> C1 (13 bits) */
|
|
/* 7 -> S1 (4 bits) */
|
|
/* 8 -> GA1(3 bits) */
|
|
/* 9 -> GB1(4 bits) */
|
|
/* 10 -> P2 (5 bits) */
|
|
/* 11 -> C2 (13 bits) */
|
|
/* 12 -> S2 (4 bits) */
|
|
/* 13 -> GA2(3 bits) */
|
|
/* 14 -> GB2(4 bits) */
|
|
/* parameters: */
|
|
/* -(i) parameters : 16 values parameters array */
|
|
/* -(o) bitStream : the 16 values streamed on 80 bits in a */
|
|
/* 10*8bits values array */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void parametersArray2BitStream(uint16_t parameters[], uint8_t bitStream[]);
|
|
|
|
/*****************************************************************************/
|
|
/* parametersArray2BitStream : convert bitStream to an array of parameters */
|
|
/* reverse operation of previous funtion */
|
|
/* parameters: */
|
|
/* -(i) bitStream : the 16 values streamed on 80 bits in a */
|
|
/* 10*8bits values array */
|
|
/* -(o) parameters : 16 values parameters array */
|
|
/* */
|
|
/*****************************************************************************/
|
|
void parametersBitStream2Array(uint8_t bitStream[], uint16_t parameters[]);
|
|
#endif /* ifndef UTILS_H */
|