diff options
Diffstat (limited to 'media/libstagefright/codecs/amrnb/common/src/q_plsf_5.cpp')
-rw-r--r-- | media/libstagefright/codecs/amrnb/common/src/q_plsf_5.cpp | 691 |
1 files changed, 691 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/amrnb/common/src/q_plsf_5.cpp b/media/libstagefright/codecs/amrnb/common/src/q_plsf_5.cpp new file mode 100644 index 0000000..2f9e40e --- /dev/null +++ b/media/libstagefright/codecs/amrnb/common/src/q_plsf_5.cpp @@ -0,0 +1,691 @@ +/* ------------------------------------------------------------------ + * Copyright (C) 1998-2009 PacketVideo + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. + * See the License for the specific language governing permissions + * and limitations under the License. + * ------------------------------------------------------------------- + */ +/**************************************************************************************** +Portions of this file are derived from the following 3GPP standard: + + 3GPP TS 26.073 + ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec + Available from http://www.3gpp.org + +(C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC) +Permission to distribute, modify and use this file under the standard license +terms listed above has been obtained from the copyright holder. +****************************************************************************************/ +/* + Pathname: ./audio/gsm-amr/c/src/q_plsf_5.c + Funtions: + +------------------------------------------------------------------------------ + REVISION HISTORY + + Description: Placed code in the PV standard template format. + Updated to accept new parameter, Flag *pOverflow. + + Description: + Eliminated unused include files. + For Vq_subvec() + 1. Eliminated math operations that unnecessary checked for + saturation (number are bounded to 2^12) + 2. Eliminated access to (slow) memory by using axiliar variables + 3. Because this routine is looking for the minimum distance, + introduced 3 check conditions inside the loop, so when the + partial distance is bigger than the minimun distance, the + loop is not completed and process continue with next iteration + For Vq_subvec_s() + 1. Eliminated math operations that unnecessary checked for + saturation (number are bounded to 2^12) + 2. Combined increasing and decreasing loops to avoid double + accesses to the same table element + 3. Eliminated access to (slow) memory by using axiliar variables + 4. Because this routine is looking for the minimum distance, + introduced 2 check conditions inside the loop, so when the + partial distance is bigger than the minimun distance, the + loop is not completed and process continue with next iteration + For Q_plsf_5() + 1. Eliminated math operations that unnecessary checked for + saturation (number are bounded to 2^12) + 2. Replaced array addressing by pointers + + Description: Replaced OSCL mem type functions and eliminated include + files that now are chosen by OSCL definitions + + Description: Replaced "int" and/or "char" with OSCL defined types. + + + Description: Added #ifdef __cplusplus around extern'ed table. + + Who: Date: + Description: + +------------------------------------------------------------------------------ + MODULE DESCRIPTION + + +------------------------------------------------------------------------------ +*/ + +/*---------------------------------------------------------------------------- +; INCLUDES +----------------------------------------------------------------------------*/ +#include "q_plsf.h" +#include "typedef.h" +#include "basic_op.h" +#include "lsp_lsf.h" +#include "reorder.h" +#include "lsfwt.h" + +/*--------------------------------------------------------------------------*/ +#ifdef __cplusplus +extern "C" +{ +#endif + + /*---------------------------------------------------------------------------- + ; MACROS + ; Define module specific macros here + ----------------------------------------------------------------------------*/ + + /*---------------------------------------------------------------------------- + ; DEFINES + ; Include all pre-processor statements here. Include conditional + ; compile variables also. + ----------------------------------------------------------------------------*/ + + /*---------------------------------------------------------------------------- + ; LOCAL FUNCTION DEFINITIONS + ; Function Prototype declaration + ----------------------------------------------------------------------------*/ + + /*---------------------------------------------------------------------------- + ; LOCAL VARIABLE DEFINITIONS + ; Variable declaration - defined here and used outside this module + ----------------------------------------------------------------------------*/ + + /*---------------------------------------------------------------------------- + ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES + ; Declare variables used in this module but defined elsewhere + ----------------------------------------------------------------------------*/ + /* Codebooks of LSF prediction residual */ + extern const Word16 mean_lsf_5[]; + + extern const Word16 dico1_lsf_5[]; + extern const Word16 dico2_lsf_5[]; + extern const Word16 dico3_lsf_5[]; + extern const Word16 dico4_lsf_5[]; + extern const Word16 dico5_lsf_5[]; + + /*--------------------------------------------------------------------------*/ +#ifdef __cplusplus +} +#endif + +/* +------------------------------------------------------------------------------ + FUNCTION NAME: Vq_subvec +------------------------------------------------------------------------------ + INPUT AND OUTPUT DEFINITIONS + + Inputs: + lsf_r1 -- array of type Word16 -- 1st LSF residual vector, Q15 + lsf_r2 -- array of type Word16 -- 2nd LSF residual vector, Q15 + dico -- pointer to const Word16 -- quantization codebook, Q15 + wf1 -- array of type Word16 -- 1st LSF weighting factors, Q13 + wf2 -- array of type Word16 -- 2nd LSF weighting factors, Q13 + dico_size -- Word16 -- size of quantization codebook, Q0 + Outputs: + pOverflow -- pointer to type Flag -- overflow indicator + + Returns: + Word16 -- quantization index, Q0 + + Global Variables Used: + None + + Local Variables Needed: + None + +------------------------------------------------------------------------------ + FUNCTION DESCRIPTION + + This function performs the quantization of a 4-dimensional subvector. + +------------------------------------------------------------------------------ + REQUIREMENTS + + None + +------------------------------------------------------------------------------ + REFERENCES + + q_plsf_5.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 + +------------------------------------------------------------------------------ + PSEUDO-CODE + + +------------------------------------------------------------------------------ + RESOURCES USED [optional] + + When the code is written for a specific target processor the + the resources used should be documented below. + + HEAP MEMORY USED: x bytes + + STACK MEMORY USED: x bytes + + CLOCK CYCLES: (cycle count equation for this function) + (variable + used to represent cycle count for each subroutine + called) + where: (cycle count variable) = cycle count for [subroutine + name] + +------------------------------------------------------------------------------ + CAUTION [optional] + [State any special notes, constraints or cautions for users of this function] + +------------------------------------------------------------------------------ +*/ +/* Quantization of a 4 dimensional subvector */ + +static Word16 Vq_subvec( /* o : quantization index, Q0 */ + Word16 *lsf_r1, /* i : 1st LSF residual vector, Q15 */ + Word16 *lsf_r2, /* i : 2nd LSF residual vector, Q15 */ + const Word16 *dico, /* i : quantization codebook, Q15 */ + Word16 *wf1, /* i : 1st LSF weighting factors Q13 */ + Word16 *wf2, /* i : 2nd LSF weighting factors Q13 */ + Word16 dico_size, /* i : size of quantization codebook, Q0 */ + Flag *pOverflow /* o : overflow indicator */ +) +{ + Word16 index = 0; /* initialization only needed to keep gcc silent */ + Word16 i; + Word16 temp; + const Word16 *p_dico; + Word32 dist_min; + Word32 dist; + Word16 wf1_0; + Word16 wf1_1; + Word16 wf2_0; + Word16 wf2_1; + Word32 aux1; + Word32 aux2; + Word32 aux3; + Word32 aux4; + + OSCL_UNUSED_ARG(pOverflow); + + dist_min = MAX_32; + p_dico = dico; + + wf1_0 = wf1[0]; + wf1_1 = wf1[1]; + wf2_0 = wf2[0]; + wf2_1 = wf2[1]; + + aux1 = ((Word32) lsf_r1[0] * wf1_0); + aux2 = ((Word32) lsf_r1[1] * wf1_1); + aux3 = ((Word32) lsf_r2[0] * wf2_0); + aux4 = ((Word32) lsf_r2[1] * wf2_1); + + for (i = 0; i < dico_size; i++) + { + temp = (aux1 - ((Word32)wf1_0 * *(p_dico++))) >> 15; + dist = ((Word32)temp * temp); + + if (dist >= dist_min) + { + p_dico += 3; + continue; + } + + temp = (aux2 - ((Word32)wf1_1 * *(p_dico++))) >> 15; + dist += ((Word32)temp * temp); + + if (dist >= dist_min) + { + p_dico += 2; + continue; + } + + temp = (aux3 - ((Word32)wf2_0 * *(p_dico++))) >> 15; + dist += ((Word32)temp * temp); + + if (dist >= dist_min) + { + p_dico += 1; + continue; + } + + temp = (aux4 - ((Word32)wf2_1 * *(p_dico++))) >> 15; + dist += ((Word32)temp * temp); + + + if (dist < dist_min) + { + dist_min = dist; + index = i; + } + } + + + + /* Reading the selected vector */ + + p_dico = &dico[ index<<2]; + lsf_r1[0] = *p_dico++; + lsf_r1[1] = *p_dico++; + lsf_r2[0] = *p_dico++; + lsf_r2[1] = *p_dico; + + return index; + +} + + +/* +------------------------------------------------------------------------------ + FUNCTION NAME: Vq_subvec_s +------------------------------------------------------------------------------ + INPUT AND OUTPUT DEFINITIONS + + Inputs: + lsf_r1 -- array of type Word16 -- 1st LSF residual vector, Q15 + lsf_r2 -- array of type Word16 -- 2nd LSF residual vector, Q15 + dico -- pointer to const Word16 -- quantization codebook, Q15 + wf1 -- array of type Word16 -- 1st LSF weighting factors, Q13 + wf2 -- array of type Word16 -- 2nd LSF weighting factors, Q13 + dico_size -- Word16 -- size of quantization codebook, Q0 + + Outputs: + pOverflow -- pointer to type Flag -- overflow indicator + + Returns: + Word16 -- quantization index, Q0 + + Global Variables Used: + None + + Local Variables Needed: + None + +------------------------------------------------------------------------------ + FUNCTION DESCRIPTION + + This function performs the quantization of a 4-dimensional subvector. + +------------------------------------------------------------------------------ + REQUIREMENTS + + None + +------------------------------------------------------------------------------ + REFERENCES + + q_plsf_5.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 + +------------------------------------------------------------------------------ + PSEUDO-CODE + + +------------------------------------------------------------------------------ + RESOURCES USED [optional] + + When the code is written for a specific target processor the + the resources used should be documented below. + + HEAP MEMORY USED: x bytes + + STACK MEMORY USED: x bytes + + CLOCK CYCLES: (cycle count equation for this function) + (variable + used to represent cycle count for each subroutine + called) + where: (cycle count variable) = cycle count for [subroutine + name] + +------------------------------------------------------------------------------ + CAUTION [optional] + [State any special notes, constraints or cautions for users of this function] + +------------------------------------------------------------------------------ +*/ + + +/* Quantization of a 4 dimensional subvector with a signed codebook */ + +static Word16 Vq_subvec_s( /* o : quantization index Q0 */ + Word16 *lsf_r1, /* i : 1st LSF residual vector Q15 */ + Word16 *lsf_r2, /* i : and LSF residual vector Q15 */ + const Word16 *dico, /* i : quantization codebook Q15 */ + Word16 *wf1, /* i : 1st LSF weighting factors Q13 */ + Word16 *wf2, /* i : 2nd LSF weighting factors Q13 */ + Word16 dico_size, /* i : size of quantization codebook Q0 */ + Flag *pOverflow) /* o : overflow indicator */ +{ + Word16 index = 0; /* initialization only needed to keep gcc silent */ + Word16 sign = 0; /* initialization only needed to keep gcc silent */ + Word16 i; + Word16 temp; + Word16 temp1; + Word16 temp2; + const Word16 *p_dico; + Word32 dist_min; + Word32 dist1; + Word32 dist2; + + Word16 lsf_r1_0; + Word16 lsf_r1_1; + Word16 lsf_r2_0; + Word16 lsf_r2_1; + + Word16 wf1_0; + Word16 wf1_1; + Word16 wf2_0; + Word16 wf2_1; + + OSCL_UNUSED_ARG(pOverflow); + + dist_min = MAX_32; + p_dico = dico; + + + lsf_r1_0 = lsf_r1[0]; + lsf_r1_1 = lsf_r1[1]; + lsf_r2_0 = lsf_r2[0]; + lsf_r2_1 = lsf_r2[1]; + + wf1_0 = wf1[0]; + wf1_1 = wf1[1]; + wf2_0 = wf2[0]; + wf2_1 = wf2[1]; + + for (i = 0; i < dico_size; i++) + { + /* test positive */ + temp = *p_dico++; + temp1 = lsf_r1_0 - temp; + temp2 = lsf_r1_0 + temp; + temp1 = ((Word32)wf1_0 * temp1) >> 15; + temp2 = ((Word32)wf1_0 * temp2) >> 15; + dist1 = ((Word32)temp1 * temp1); + dist2 = ((Word32)temp2 * temp2); + + temp = *p_dico++; + temp1 = lsf_r1_1 - temp; + temp2 = lsf_r1_1 + temp; + temp1 = ((Word32)wf1_1 * temp1) >> 15; + temp2 = ((Word32)wf1_1 * temp2) >> 15; + dist1 += ((Word32)temp1 * temp1); + dist2 += ((Word32)temp2 * temp2); + + if ((dist1 >= dist_min) && (dist2 >= dist_min)) + { + p_dico += 2; + continue; + } + + temp = *p_dico++; + temp1 = lsf_r2_0 - temp; + temp2 = lsf_r2_0 + temp; + temp1 = ((Word32)wf2_0 * temp1) >> 15; + temp2 = ((Word32)wf2_0 * temp2) >> 15; + dist1 += ((Word32)temp1 * temp1); + dist2 += ((Word32)temp2 * temp2); + + temp = *p_dico++; + temp1 = lsf_r2_1 - temp; + temp2 = lsf_r2_1 + temp; + temp1 = ((Word32)wf2_1 * temp1) >> 15; + temp2 = ((Word32)wf2_1 * temp2) >> 15; + dist1 += ((Word32)temp1 * temp1); + dist2 += ((Word32)temp2 * temp2); + + if (dist1 < dist_min) + { + dist_min = dist1; + index = i; + sign = 0; + } + + /* test negative */ + + if (dist2 < dist_min) + { + dist_min = dist2; + index = i; + sign = 1; + } + } + + /* Reading the selected vector */ + + p_dico = &dico[index<<2]; + index <<= 1; + if (sign) + { + lsf_r1[0] = - (*p_dico++); + lsf_r1[1] = - (*p_dico++); + lsf_r2[0] = - (*p_dico++); + lsf_r2[1] = - (*p_dico); + index += 1; + } + else + { + lsf_r1[0] = *p_dico++; + lsf_r1[1] = *p_dico++; + lsf_r2[0] = *p_dico++; + lsf_r2[1] = *p_dico; + } + + return index; + +} + +/* +------------------------------------------------------------------------------ + FUNCTION NAME: Q_plsf_5 +------------------------------------------------------------------------------ + INPUT AND OUTPUT DEFINITIONS + + + Inputs: + st -- pointer to Q_plsfState -- state information + lsp1 -- array of type Word16 -- 1st LSP vector, Q15 + lsp2 -- array of type Word16 -- 2nd LSP vector, Q15 + + Outputs: + lps1_q -- array of type Word16 -- quantized 1st LSP vector, Q15 + lps2_q -- array of type Word16 -- quantized 2nd LSP vector, Q15 + indices -- array of type Word16 -- quantization indices of 5 matrics, Q0 + pOverflow -- pointer to type Flag -- overflow indicator + + Returns: + None + + Global Variables Used: + mean_lsf_5[]; + + dico1_lsf_5[]; + dico2_lsf_5[]; + dico3_lsf_5[]; + dico4_lsf_5[]; + dico5_lsf_5[]; + + Local Variables Needed: + None + +------------------------------------------------------------------------------ + FUNCTION DESCRIPTION + + PURPOSE: Quantization of 2 sets of LSF parameters using 1st order MA + prediction and split by 5 matrix quantization (split-MQ) + + DESCRIPTION: + + p[i] = pred_factor*past_rq[i]; i=0,...,m-1 + r1[i]= lsf1[i] - p[i]; i=0,...,m-1 + r2[i]= lsf2[i] - p[i]; i=0,...,m-1 + where: + lsf1[i] 1st mean-removed LSF vector. + lsf2[i] 2nd mean-removed LSF vector. + r1[i] 1st residual prediction vector. + r2[i] 2nd residual prediction vector. + past_r2q[i] Past quantized residual (2nd vector). + + The residual vectors r1[i] and r2[i] are jointly quantized using + split-MQ with 5 codebooks. Each 4th dimension submatrix contains 2 + elements from each residual vector. The 5 submatrices are as follows: + {r1[0], r1[1], r2[0], r2[1]}; {r1[2], r1[3], r2[2], r2[3]}; + {r1[4], r1[5], r2[4], r2[5]}; {r1[6], r1[7], r2[6], r2[7]}; + {r1[8], r1[9], r2[8], r2[9]} + +------------------------------------------------------------------------------ + REQUIREMENTS + + None + +------------------------------------------------------------------------------ + REFERENCES + + q_plsf_5.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001 + +------------------------------------------------------------------------------ + PSEUDO-CODE + + +------------------------------------------------------------------------------ + RESOURCES USED [optional] + + When the code is written for a specific target processor the + the resources used should be documented below. + + HEAP MEMORY USED: x bytes + + STACK MEMORY USED: x bytes + + CLOCK CYCLES: (cycle count equation for this function) + (variable + used to represent cycle count for each subroutine + called) + where: (cycle count variable) = cycle count for [subroutine + name] + +------------------------------------------------------------------------------ + CAUTION [optional] + [State any special notes, constraints or cautions for users of this function] + +------------------------------------------------------------------------------ +*/ + +void Q_plsf_5( + Q_plsfState *st, + Word16 *lsp1, /* i : 1st LSP vector, Q15 */ + Word16 *lsp2, /* i : 2nd LSP vector, Q15 */ + Word16 *lsp1_q, /* o : quantized 1st LSP vector, Q15 */ + Word16 *lsp2_q, /* o : quantized 2nd LSP vector, Q15 */ + Word16 *indice, /* o : quantization indices of 5 matrices, Q0 */ + Flag *pOverflow /* o : overflow indicator */ +) +{ + Word16 i; + Word16 lsf1[M]; + Word16 lsf2[M]; + Word16 wf1[M]; + Word16 wf2[M]; + Word16 lsf_p[M]; + Word16 lsf_r1[M]; + Word16 lsf_r2[M]; + Word16 lsf1_q[M]; + Word16 lsf2_q[M]; + + Word16 *p_lsf_p; + Word16 *p_lsf1; + Word16 *p_lsf2; + Word16 *p_lsf_r1; + Word16 *p_lsf_r2; + + /* convert LSFs to normalize frequency domain 0..16384 */ + + Lsp_lsf(lsp1, lsf1, M, pOverflow); + Lsp_lsf(lsp2, lsf2, M, pOverflow); + + /* Compute LSF weighting factors (Q13) */ + + Lsf_wt(lsf1, wf1, pOverflow); + Lsf_wt(lsf2, wf2, pOverflow); + + /* Compute predicted LSF and prediction error */ + + p_lsf_p = &lsf_p[0]; + p_lsf1 = &lsf1[0]; + p_lsf2 = &lsf2[0]; + p_lsf_r1 = &lsf_r1[0]; + p_lsf_r2 = &lsf_r2[0]; + + for (i = 0; i < M; i++) + { + *(p_lsf_p) = mean_lsf_5[i] + + (((Word32)st->past_rq[i] * LSP_PRED_FAC_MR122) >> 15); + + *(p_lsf_r1++) = *(p_lsf1++) - *(p_lsf_p); + *(p_lsf_r2++) = *(p_lsf2++) - *(p_lsf_p++); + } + + /*---- Split-MQ of prediction error ----*/ + + indice[0] = Vq_subvec(&lsf_r1[0], &lsf_r2[0], dico1_lsf_5, + &wf1[0], &wf2[0], DICO1_5_SIZE, pOverflow); + + indice[1] = Vq_subvec(&lsf_r1[2], &lsf_r2[2], dico2_lsf_5, + &wf1[2], &wf2[2], DICO2_5_SIZE, pOverflow); + + indice[2] = Vq_subvec_s(&lsf_r1[4], &lsf_r2[4], dico3_lsf_5, + &wf1[4], &wf2[4], DICO3_5_SIZE, pOverflow); + + indice[3] = Vq_subvec(&lsf_r1[6], &lsf_r2[6], dico4_lsf_5, + &wf1[6], &wf2[6], DICO4_5_SIZE, pOverflow); + + indice[4] = Vq_subvec(&lsf_r1[8], &lsf_r2[8], dico5_lsf_5, + &wf1[8], &wf2[8], DICO5_5_SIZE, pOverflow); + + /* Compute quantized LSFs and update the past quantized residual */ + + p_lsf_r1 = &lsf_r1[0]; + p_lsf_r2 = &lsf_r2[0]; + p_lsf_p = &lsf_p[0]; + p_lsf1 = &lsf1_q[0]; + p_lsf2 = &lsf2_q[0]; + + + for (i = 0; i < M; i++) + { + *(p_lsf1++) = *(p_lsf_r1++) + *(p_lsf_p); + *(p_lsf2++) = *(p_lsf_r2) + *(p_lsf_p++); + st->past_rq[i] = *(p_lsf_r2++); + } + + /* verification that LSFs has minimum distance of LSF_GAP */ + + Reorder_lsf(lsf1_q, LSF_GAP, M, pOverflow); + Reorder_lsf(lsf2_q, LSF_GAP, M, pOverflow); + + /* convert LSFs to the cosine domain */ + + Lsf_lsp(lsf1_q, lsp1_q, M, pOverflow); + Lsf_lsp(lsf2_q, lsp2_q, M, pOverflow); +} + |