| /* ------------------------------------------------------------------ |
| * 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/d8_31pf.c |
| Functions: |
| |
| |
| Date: 01/28/2002 |
| |
| ------------------------------------------------------------------------------ |
| REVISION HISTORY |
| |
| Description: Modified to pass overflow flag through to basic math function. |
| The flag is passed back to the calling function by pointer reference. |
| |
| Description: Per review comments... |
| (1) Removed include of "count.h" and "basic_op.h" |
| (2) Added includes of mult.h, shl.h, shr.h, add.h, sub.h, negate.h, |
| L_mult.h, and L_shr.h |
| |
| Description: Replaced "int" and/or "char" with OSCL defined types. |
| |
| Description: |
| |
| ------------------------------------------------------------------------------ |
| MODULE DESCRIPTION |
| */ |
| |
| /*---------------------------------------------------------------------------- |
| ; INCLUDES |
| ----------------------------------------------------------------------------*/ |
| #include "d8_31pf.h" |
| #include "typedef.h" |
| #include "basic_op.h" |
| #include "cnst.h" |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; MACROS |
| ; Define module specific macros here |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; DEFINES |
| ; Include all pre-processor statements here. Include conditional |
| ; compile variables also. |
| ----------------------------------------------------------------------------*/ |
| #define NB_PULSE 8 /* number of pulses */ |
| |
| /* define values/representation for output codevector and sign */ |
| #define POS_CODE 8191 |
| #define NEG_CODE 8191 |
| |
| |
| /*---------------------------------------------------------------------------- |
| ; LOCAL FUNCTION DEFINITIONS |
| ; Function Prototype declaration |
| ----------------------------------------------------------------------------*/ |
| |
| /*---------------------------------------------------------------------------- |
| ; LOCAL VARIABLE DEFINITIONS |
| ; Variable declaration - defined here and used outside this module |
| ----------------------------------------------------------------------------*/ |
| |
| /* |
| ------------------------------------------------------------------------------ |
| FUNCTION NAME: decompress10 |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| MSBs -- Word16 -- MSB part of the index |
| LSBs -- Word16 -- LSB part of the index |
| index1 -- Word16 -- index for first pos in pos_index[] |
| index2 -- Word16 -- index for second pos in pos_index[] |
| index3 -- Word16 -- index for third pos in pos_index[] |
| |
| Outputs: |
| pos_indx[] -- array of type Word16 -- position of 3 pulses (decompressed) |
| |
| pOverflow Flag set when overflow occurs, pointer of type Flag * |
| |
| Returns: |
| None |
| |
| Global Variables Used: |
| None |
| |
| Local Variables Needed: |
| None |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| None |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| |
| d8_31pf.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] |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| static void decompress10( |
| Word16 MSBs, /* i : MSB part of the index */ |
| Word16 LSBs, /* i : LSB part of the index */ |
| Word16 index1, /* i : index for first pos in pos_index[] */ |
| Word16 index2, /* i : index for second pos in pos_index[] */ |
| Word16 index3, /* i : index for third pos in pos_index[] */ |
| Word16 pos_indx[], /* o : position of 3 pulses (decompressed) */ |
| Flag *pOverflow) /* o : Flag set when overflow occurs */ |
| { |
| Word16 ia; |
| Word16 ib; |
| Word16 ic; |
| Word32 tempWord32; |
| |
| /* |
| pos_indx[index1] = ((MSBs-25*(MSBs/25))%5)*2 + (LSBs-4*(LSBs/4))%2; |
| pos_indx[index2] = ((MSBs-25*(MSBs/25))/5)*2 + (LSBs-4*(LSBs/4))/2; |
| pos_indx[index3] = (MSBs/25)*2 + LSBs/4; |
| */ |
| |
| if (MSBs > 124) |
| { |
| MSBs = 124; |
| } |
| |
| ia = |
| mult( |
| MSBs, |
| 1311, |
| pOverflow); |
| |
| tempWord32 = |
| L_mult( |
| ia, |
| 25, |
| pOverflow); |
| |
| |
| ia = (Word16)(MSBs - (tempWord32 >> 1)); |
| ib = |
| mult( |
| ia, |
| 6554, |
| pOverflow); |
| |
| tempWord32 = |
| L_mult( |
| ib, |
| 5, |
| pOverflow); |
| |
| ib = ia - (Word16)(tempWord32 >> 1); |
| |
| ib = |
| shl( |
| ib, |
| 1, |
| pOverflow); |
| |
| |
| ic = LSBs - ((LSBs >> 2) << 2); |
| |
| |
| pos_indx[index1] = ib + (ic & 1); |
| |
| |
| ib = |
| mult( |
| ia, |
| 6554, |
| pOverflow); |
| |
| ib = |
| shl( |
| ib, |
| 1, |
| pOverflow); |
| |
| |
| pos_indx[index2] = ib + (ic >> 1); |
| |
| |
| ib = LSBs >> 2; |
| |
| ic = |
| mult( |
| MSBs, |
| 1311, |
| pOverflow); |
| |
| ic = |
| shl( |
| ic, |
| 1, |
| pOverflow); |
| |
| pos_indx[index3] = |
| add( |
| ib, |
| ic, |
| pOverflow); |
| |
| return; |
| } |
| |
| |
| /* |
| ------------------------------------------------------------------------------ |
| FUNCTION NAME: decompress_code |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| indx[] -- array of type Word16 -- position and sign of |
| 8 pulses (compressed) |
| |
| Outputs: |
| sign_indx[] -- array of type Word16 -- signs of 4 pulses (signs only) |
| pos_indx[] -- array of type Word16 -- position index of 8 pulses |
| (position only) |
| pOverflow pointer to type Flag -- Flag set when overflow occurs |
| |
| Returns: |
| None |
| |
| Global Variables Used: |
| None |
| |
| Local Variables Needed: |
| None |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| PURPOSE: decompression of the linear codewords to 4+three indeces |
| one bit from each pulse is made robust to errors by |
| minimizing the phase shift of a bit error. |
| 4 signs (one for each track) |
| i0,i4,i1 => one index (7+3) bits, 3 LSBs more robust |
| i2,i6,i5 => one index (7+3) bits, 3 LSBs more robust |
| i3,i7 => one index (5+2) bits, 2-3 LSbs more robust |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| None |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| |
| d8_31pf.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] |
| |
| ------------------------------------------------------------------------------ |
| */ |
| |
| static void decompress_code( |
| Word16 indx[], /* i : position and sign of 8 pulses (compressed) */ |
| Word16 sign_indx[], /* o : signs of 4 pulses (signs only) */ |
| Word16 pos_indx[], /* o : position index of 8 pulses (position only) */ |
| Flag *pOverflow /* o : Flag set when overflow occurs */ |
| ) |
| { |
| Word16 i; |
| Word16 ia; |
| Word16 ib; |
| Word16 MSBs; |
| Word16 LSBs; |
| Word16 MSBs0_24; |
| Word32 tempWord32; |
| |
| for (i = 0; i < NB_TRACK_MR102; i++) |
| { |
| sign_indx[i] = indx[i]; |
| } |
| |
| /* |
| First index: 10x10x10 -> 2x5x2x5x2x5-> 125x2x2x2 -> 7+1x3 bits |
| MSBs = indx[NB_TRACK]/8; |
| LSBs = indx[NB_TRACK]%8; |
| */ |
| MSBs = indx[NB_TRACK_MR102] >> 3; |
| |
| LSBs = indx[NB_TRACK_MR102] & 0x7; |
| |
| decompress10( |
| MSBs, |
| LSBs, |
| 0, |
| 4, |
| 1, |
| pos_indx, |
| pOverflow); |
| |
| /* |
| Second index: 10x10x10 -> 2x5x2x5x2x5-> 125x2x2x2 -> 7+1x3 bits |
| MSBs = indx[NB_TRACK+1]/8; |
| LSBs = indx[NB_TRACK+1]%8; |
| */ |
| MSBs = indx[NB_TRACK_MR102+1] >> 3; |
| |
| LSBs = indx[NB_TRACK_MR102+1] & 0x7; |
| |
| decompress10( |
| MSBs, |
| LSBs, |
| 2, |
| 6, |
| 5, |
| pos_indx, |
| pOverflow); |
| |
| /* |
| Third index: 10x10 -> 2x5x2x5-> 25x2x2 -> 5+1x2 bits |
| MSBs = indx[NB_TRACK+2]/4; |
| LSBs = indx[NB_TRACK+2]%4; |
| MSBs0_24 = (MSBs*25+12)/32; |
| if ((MSBs0_24/5)%2==1) |
| pos_indx[3] = (4-(MSBs0_24%5))*2 + LSBs%2; |
| else |
| pos_indx[3] = (MSBs0_24%5)*2 + LSBs%2; |
| pos_indx[7] = (MSBs0_24/5)*2 + LSBs/2; |
| */ |
| |
| MSBs = indx[NB_TRACK_MR102+2] >> 2; |
| |
| LSBs = indx[NB_TRACK_MR102+2] & 0x3; |
| |
| tempWord32 = |
| L_mult( |
| MSBs, |
| 25, |
| pOverflow); |
| |
| ia = |
| (Word16) |
| L_shr( |
| tempWord32, |
| 1, |
| pOverflow); |
| |
| ia += 12; |
| |
| MSBs0_24 = ia >> 5; |
| |
| |
| ia = |
| mult( |
| MSBs0_24, |
| 6554, |
| pOverflow); |
| |
| ia &= 1; |
| |
| |
| ib = |
| mult( |
| MSBs0_24, |
| 6554, |
| pOverflow); |
| |
| tempWord32 = |
| L_mult( |
| ib, |
| 5, |
| pOverflow); |
| |
| |
| ib = MSBs0_24 - (Word16)(tempWord32 >> 1); |
| |
| if (ia == 1) |
| { |
| ib = 4 - ib; |
| |
| } |
| |
| |
| ib = |
| shl( |
| ib, |
| 1, |
| pOverflow); |
| |
| ia = LSBs & 0x1; |
| |
| pos_indx[3] = |
| add( |
| ib, |
| ia, |
| pOverflow); |
| |
| ia = |
| mult( |
| MSBs0_24, |
| 6554, |
| pOverflow); |
| |
| ia = |
| shl( |
| ia, |
| 1, |
| pOverflow); |
| |
| pos_indx[7] = ia + (LSBs >> 1); |
| |
| } |
| |
| /* |
| ------------------------------------------------------------------------------ |
| FUNCTION NAME: dec_8i40_31bits |
| ------------------------------------------------------------------------------ |
| INPUT AND OUTPUT DEFINITIONS |
| |
| Inputs: |
| index array of type Word16 -- index of 8 pulses (sign+position) |
| |
| Outputs: |
| cod array of type Word16 -- algebraic (fixed) codebook excitation |
| pOverflow pointer to type Flag -- Flag set when overflow occurs |
| |
| Returns: |
| None |
| |
| Global Variables Used: |
| None |
| |
| Local Variables Needed: |
| None |
| |
| ------------------------------------------------------------------------------ |
| FUNCTION DESCRIPTION |
| |
| PURPOSE: Builds the innovative codevector from the received |
| index of algebraic codebook. |
| |
| ------------------------------------------------------------------------------ |
| REQUIREMENTS |
| |
| None |
| |
| ------------------------------------------------------------------------------ |
| REFERENCES |
| |
| d8_31pf.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 dec_8i40_31bits( |
| Word16 index[], /* i : index of 8 pulses (sign+position) */ |
| Word16 cod[], /* o : algebraic (fixed) codebook excitation */ |
| Flag *pOverflow /* o : Flag set when overflow occurs */ |
| ) |
| { |
| Word16 i; |
| Word16 j; |
| Word16 pos1; |
| Word16 pos2; |
| Word16 sign; |
| |
| Word16 linear_signs[NB_TRACK_MR102]; |
| Word16 linear_codewords[NB_PULSE]; |
| |
| for (i = 0; i < L_CODE; i++) |
| { |
| cod[i] = 0; |
| } |
| |
| decompress_code( |
| index, |
| linear_signs, |
| linear_codewords, |
| pOverflow); |
| |
| /* decode the positions and signs of pulses and build the codeword */ |
| for (j = 0; j < NB_TRACK_MR102; j++) /* NB_TRACK_MR102 = 4 */ |
| { |
| /* position of pulse "j" */ |
| |
| pos1 = (linear_codewords[j] << 2) + j; |
| |
| |
| if (linear_signs[j] == 0) |
| { |
| sign = POS_CODE; /* +1.0 */ |
| } |
| else |
| { |
| sign = -NEG_CODE; /* -1.0 */ |
| } |
| |
| if (pos1 < L_SUBFR) |
| { |
| cod[pos1] = sign; /* avoid buffer overflow */ |
| } |
| |
| /* compute index i */ |
| /* position of pulse "j+4" */ |
| |
| pos2 = (linear_codewords[j + 4] << 2) + j; |
| |
| |
| if (pos2 < pos1) |
| { |
| sign = negate(sign); |
| } |
| |
| if (pos2 < L_SUBFR) |
| { |
| cod[pos2] += sign; /* avoid buffer overflow */ |
| } |
| |
| |
| } /* for (j = 0; j < NB_TRACK_MR102; j++) */ |
| |
| return; |
| } |
