a_refl.cpp revision 4f1efc098cb5791c3e9f483f2af84aef70d2d0a0 
1/* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18/****************************************************************************************
19Portions of this file are derived from the following 3GPP standard:
20
21    3GPP TS 26.073
22    ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec
23    Available from http://www.3gpp.org
24
25(C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
26Permission to distribute, modify and use this file under the standard license
27terms listed above has been obtained from the copyright holder.
28****************************************************************************************/
29/*
30------------------------------------------------------------------------------
31
32
33
34 Filename:  /audio/gsm-amr/c/src/a_refl.c
35 Functions: a_refl
36
37     Date: 02/05/2002
38
39------------------------------------------------------------------------------
40 REVISION HISTORY
41
42 Description: Removing unneeded include files and the goto statement.
43
44
45 Description: Changed function name to pv_round to avoid conflict with
46              round function in C standard library.
47
48 Description:  Replaced "int" and/or "char" with OSCL defined types.
49
50 Description:  Using inline functions from basic_op.h .
51               Removing unneeded include files.
52
53 Description:
54
55------------------------------------------------------------------------------
56*/
57
58
59/*----------------------------------------------------------------------------
60; INCLUDES
61----------------------------------------------------------------------------*/
62#include "a_refl.h"
63#include "typedef.h"
64#include "cnst.h"
65#include "basic_op.h"
66
67/*----------------------------------------------------------------------------
68; MACROS [optional]
69; [Define module specific macros here]
70----------------------------------------------------------------------------*/
71
72/*----------------------------------------------------------------------------
73; DEFINES [optional]
74; [Include all pre-processor statements here. Include conditional
75; compile variables also.]
76----------------------------------------------------------------------------*/
77
78/*----------------------------------------------------------------------------
79; LOCAL FUNCTION DEFINITIONS
80; [List function prototypes here]
81----------------------------------------------------------------------------*/
82
83/*----------------------------------------------------------------------------
84; LOCAL VARIABLE DEFINITIONS
85; [Variable declaration - defined here and used outside this module]
86----------------------------------------------------------------------------*/
87
88/*
89------------------------------------------------------------------------------
90 FUNCTION NAME: AMREncode
91------------------------------------------------------------------------------
92 INPUT AND OUTPUT DEFINITIONS
93
94 Inputs:
95    a[] = pointer to directform coefficients of type Word16
96    refl[] = pointer to reflection coefficients of type Word16
97
98 Outputs:
99    pOverflow = 1 if overflow exists in the math operations else zero.
100
101 Returns:
102    None
103
104 Global Variables Used:
105    None
106
107 Local Variables Needed:
108    None
109
110------------------------------------------------------------------------------
111 FUNCTION DESCRIPTION
112
113     File             : a_refl.c
114     Purpose          : Convert from direct form coefficients to
115                        reflection coefficients
116
117------------------------------------------------------------------------------
118 REQUIREMENTS
119
120 None
121
122------------------------------------------------------------------------------
123 REFERENCES
124
125 [1] a_refl.c , 3GPP TS 26.101 version 4.1.0 Release 4, June 2001
126
127------------------------------------------------------------------------------
128 PSEUDO-CODE
129
130
131void A_Refl(
132   Word16 a[],        // i   : Directform coefficients
133   Word16 refl[]      // o   : Reflection coefficients
134)
135{
136   // local variables
137   Word16 i,j;
138   Word16 aState[M];
139   Word16 bState[M];
140   Word16 normShift;
141   Word16 normProd;
142   Word32 L_acc;
143   Word16 scale;
144   Word32 L_temp;
145   Word16 temp;
146   Word16 mult;
147
148   // initialize states
149   for (i = 0; i < M; i++)
150   {
151      aState[i] = a[i];
152   }
153
154   // backward Levinson recursion
155   for (i = M-1; i >= 0; i--)
156   {
157      if (sub(abs_s(aState[i]), 4096) >= 0)
158      {
159         goto ExitRefl;
160      }
161
162      refl[i] = shl(aState[i], 3);
163
164      L_temp = L_mult(refl[i], refl[i]);
165      L_acc = L_sub(MAX_32, L_temp);
166
167      normShift = norm_l(L_acc);
168      scale = sub(15, normShift);
169
170      L_acc = L_shl(L_acc, normShift);
171      normProd = pv_round(L_acc);
172
173      mult = div_s(16384, normProd);
174
175      for (j = 0; j < i; j++)
176      {
177         L_acc = L_deposit_h(aState[j]);
178         L_acc = L_msu(L_acc, refl[i], aState[i-j-1]);
179
180         temp = pv_round(L_acc);
181         L_temp = L_mult(mult, temp);
182         L_temp = L_shr_r(L_temp, scale);
183
184         if (L_sub(L_abs(L_temp), 32767) > 0)
185         {
186            goto ExitRefl;
187         }
188
189         bState[j] = extract_l(L_temp);
190      }
191
192      for (j = 0; j < i; j++)
193      {
194         aState[j] = bState[j];
195      }
196   }
197   return;
198
199ExitRefl:
200   for (i = 0; i < M; i++)
201   {
202      refl[i] = 0;
203   }
204}
205
206------------------------------------------------------------------------------
207 RESOURCES USED [optional]
208
209 When the code is written for a specific target processor the
210 the resources used should be documented below.
211
212 HEAP MEMORY USED: x bytes
213
214 STACK MEMORY USED: x bytes
215
216 CLOCK CYCLES: (cycle count equation for this function) + (variable
217                used to represent cycle count for each subroutine
218                called)
219     where: (cycle count variable) = cycle count for [subroutine
220                                     name]
221
222------------------------------------------------------------------------------
223 CAUTION [optional]
224 [State any special notes, constraints or cautions for users of this function]
225
226------------------------------------------------------------------------------
227*/
228
229void A_Refl(
230    Word16 a[],        /* i   : Directform coefficients */
231    Word16 refl[],     /* o   : Reflection coefficients */
232    Flag   *pOverflow
233)
234{
235    /* local variables */
236    Word16 i;
237    Word16 j;
238    Word16 aState[M];
239    Word16 bState[M];
240    Word16 normShift;
241    Word16 normProd;
242    Word32 L_acc;
243    Word16 scale;
244    Word32 L_temp;
245    Word16 temp;
246    Word16 mult;
247
248    /* initialize states */
249    for (i = 0; i < M; i++)
250    {
251        aState[i] = a[i];
252    }
253
254    /* backward Levinson recursion */
255    for (i = M - 1; i >= 0; i--)
256    {
257        if (abs_s(aState[i]) >= 4096)
258        {
259            for (i = 0; i < M; i++)
260            {
261                refl[i] = 0;
262            }
263            break;
264        }
265
266        refl[i] = shl(aState[i], 3, pOverflow);
267
268        L_temp = L_mult(refl[i], refl[i], pOverflow);
269        L_acc = L_sub(MAX_32, L_temp, pOverflow);
270
271        normShift = norm_l(L_acc);
272        scale = sub(15, normShift, pOverflow);
273
274        L_acc = L_shl(L_acc, normShift, pOverflow);
275        normProd = pv_round(L_acc, pOverflow);
276
277        mult = div_s(16384, normProd);
278
279        for (j = 0; j < i; j++)
280        {
281            L_acc = L_deposit_h(aState[j]);
282            L_acc = L_msu(L_acc, refl[i], aState[i-j-1], pOverflow);
283
284            temp = pv_round(L_acc, pOverflow);
285            L_temp = L_mult(mult, temp, pOverflow);
286            L_temp = L_shr_r(L_temp, scale, pOverflow);
287
288            if (L_abs(L_temp) > 32767)
289            {
290                for (i = 0; i < M; i++)
291                {
292                    refl[i] = 0;
293                }
294                break;
295            }
296
297            bState[j] = extract_l(L_temp);
298        }
299
300        for (j = 0; j < i; j++)
301        {
302            aState[j] = bState[j];
303        }
304    }
305    return;
306}
307
308
309
310
311
312
313
314