enc_lag3.cpp revision b841f14f8e51f2365945281fbfa54ef6a1b1b5a6 
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 Pathname: ./audio/gsm-amr/c/src/enc_lag3.c
35 Functions:
36
37     Date: 01/28/2002
38
39------------------------------------------------------------------------------
40 REVISION HISTORY
41
42 Description:  Replaced "int" and/or "char" with OSCL defined types.
43
44 Description:
45
46------------------------------------------------------------------------------
47*/
48
49/*----------------------------------------------------------------------------
50; INCLUDES
51----------------------------------------------------------------------------*/
52#include "enc_lag3.h"
53#include "typedef.h"
54#include "basic_op.h"
55#include "cnst.h"
56
57/*----------------------------------------------------------------------------
58; MACROS
59; Define module specific macros here
60----------------------------------------------------------------------------*/
61
62/*----------------------------------------------------------------------------
63; DEFINES
64; Include all pre-processor statements here. Include conditional
65; compile variables also.
66----------------------------------------------------------------------------*/
67
68
69/*----------------------------------------------------------------------------
70; LOCAL FUNCTION DEFINITIONS
71; Function Prototype declaration
72----------------------------------------------------------------------------*/
73
74
75/*----------------------------------------------------------------------------
76; LOCAL VARIABLE DEFINITIONS
77; Variable declaration - defined here and used outside this module
78----------------------------------------------------------------------------*/
79
80/*
81------------------------------------------------------------------------------
82 FUNCTION NAME: enc_lag3
83------------------------------------------------------------------------------
84 INPUT AND OUTPUT DEFINITIONS
85
86 Inputs:
87  T0 = Pitch delay of type Word16
88  T0_frac = Fractional pitch delay of type Word16
89  T0_prev = Integer pitch delay of last subframe of type Word16
90  T0_min  = minimum of search range of type Word16
91  T0_max  = maximum of search range of type Word16
92  delta_flag = Flag for 1st (or 3rd) subframe of type Word16
93  flag4   = Flag for encoding with 4 bits of type Word16
94  pOverflow = pointer indicating overflow of type Flag
95
96 Outputs:
97  pOverflow = 1 if there is an overflow else it is zero.
98
99 Returns:
100  None
101
102 Global Variables Used:
103  None
104
105 Local Variables Needed:
106  None
107
108------------------------------------------------------------------------------
109 FUNCTION DESCRIPTION
110
111 This function implements the encoding of fractional pitch lag with
112 1/3 resolution.
113
114 *   FUNCTION:  Enc_lag3
115 *
116 *   PURPOSE:  Encoding of fractional pitch lag with 1/3 resolution.
117 *
118 *   DESCRIPTION:
119 *                    First and third subframes:
120 *                    --------------------------
121 *   The pitch range is divided as follows:
122 *           19 1/3  to   84 2/3   resolution 1/3
123 *           85      to   143      resolution 1
124 *
125 *   The period is encoded with 8 bits.
126 *   For the range with fractions:
127 *     index = (T-19)*3 + frac - 1;
128 *                         where T=[19..85] and frac=[-1,0,1]
129 *   and for the integer only range
130 *     index = (T - 85) + 197;        where T=[86..143]
131 *
132 *                    Second and fourth subframes:
133 *                    ----------------------------
134 *   For the 2nd and 4th subframes a resolution of 1/3 is always used,
135 *   and the search range is relative to the lag in previous subframe.
136 *   If t0 is the lag in the previous subframe then
137 *   t_min=t0-5   and  t_max=t0+4   and  the range is given by
138 *        t_min - 2/3   to  t_max + 2/3
139 *
140 *   The period in the 2nd (and 4th) subframe is encoded with 5 bits:
141 *     index = (T-(t_min-1))*3 + frac - 1;
142 *                 where T=[t_min-1..t_max+1]
143
144------------------------------------------------------------------------------
145 REQUIREMENTS
146
147 None
148
149------------------------------------------------------------------------------
150 REFERENCES
151
152 enc_lag3.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
153
154------------------------------------------------------------------------------
155 PSEUDO-CODE
156
157   Word16 index, i, tmp_ind, uplag;
158   Word16 tmp_lag;
159
160   if (delta_flag == 0)
161   {  // if 1st or 3rd subframe
162
163      // encode pitch delay (with fraction)
164
165      if (sub (T0, 85) <= 0)
166      {
167         // index = T0*3 - 58 + T0_frac
168         i = add (add (T0, T0), T0);
169         index = add (sub (i, 58), T0_frac);
170      }
171      else
172      {
173         index = add (T0, 112);
174      }
175   }
176   else
177   {   // if second or fourth subframe
178      if (flag4 == 0) {
179
180         // 'normal' encoding: either with 5 or 6 bit resolution
181
182         // index = 3*(T0 - T0_min) + 2 + T0_frac
183         i = sub (T0, T0_min);
184         i = add (add (i, i), i);
185         index = add (add (i, 2), T0_frac);
186      }
187      else {
188
189         // encoding with 4 bit resolution
190
191         tmp_lag = T0_prev;
192
193         if ( sub( sub(tmp_lag, T0_min), 5) > 0)
194            tmp_lag = add (T0_min, 5);
195         if ( sub( sub(T0_max, tmp_lag), 4) > 0)
196            tmp_lag = sub (T0_max, 4);
197
198         uplag = add (add (add (T0, T0), T0), T0_frac);
199
200         i = sub (tmp_lag, 2);
201         tmp_ind = add (add (i, i), i);
202
203         if (sub (tmp_ind, uplag) >= 0) {
204            index = add (sub (T0, tmp_lag), 5);
205         }
206         else {
207
208            i = add (tmp_lag, 1);
209            i = add (add (i, i), i);
210
211            if (sub (i, uplag) > 0) {
212
213                index = add ( sub (uplag, tmp_ind), 3);
214            }
215            else {
216
217               index = add (sub (T0, tmp_lag), 11);
218            }
219         }
220
221      } // end if (encoding with 4 bit resolution)
222   }   // end if (second of fourth subframe)
223
224   return index;
225}
226
227------------------------------------------------------------------------------
228 RESOURCES USED [optional]
229
230 When the code is written for a specific target processor the
231 the resources used should be documented below.
232
233 HEAP MEMORY USED: x bytes
234
235 STACK MEMORY USED: x bytes
236
237 CLOCK CYCLES: (cycle count equation for this function) + (variable
238                used to represent cycle count for each subroutine
239                called)
240     where: (cycle count variable) = cycle count for [subroutine
241                                     name]
242
243------------------------------------------------------------------------------
244 CAUTION [optional]
245 [State any special notes, constraints or cautions for users of this function]
246
247------------------------------------------------------------------------------
248*/
249
250
251Word16 Enc_lag3(         /* o  : Return index of encoding             */
252    Word16 T0,           /* i  : Pitch delay                          */
253    Word16 T0_frac,      /* i  : Fractional pitch delay               */
254    Word16 T0_prev,      /* i  : Integer pitch delay of last subframe */
255    Word16 T0_min,       /* i  : minimum of search range              */
256    Word16 T0_max,       /* i  : maximum of search range              */
257    Word16 delta_flag,   /* i  : Flag for 1st (or 3rd) subframe       */
258    Word16 flag4,        /* i  : Flag for encoding with 4 bits        */
259    Flag   *pOverflow
260)
261{
262    Word16 index, i, tmp_ind, uplag;
263    Word16 tmp_lag;
264    Word16 temp1;
265    Word16 temp2;
266
267
268
269    if (delta_flag == 0)
270    {  /* if 1st or 3rd subframe */
271
272        /* encode pitch delay (with fraction) */
273        temp1 = sub(T0, 85, pOverflow);
274        if (temp1 <= 0)
275        {
276            /* index = T0*3 - 58 + T0_frac   */
277            temp2 = add(T0, T0, pOverflow);
278            i = add(temp2, T0, pOverflow);
279            temp2 = sub(i, 58, pOverflow);
280            index = add(temp2, T0_frac, pOverflow);
281        }
282        else
283        {
284            index = add(T0, 112, pOverflow);
285        }
286    }
287    else
288    {   /* if second or fourth subframe */
289        if (flag4 == 0)
290        {
291
292            /* 'normal' encoding: either with 5 or 6 bit resolution */
293
294            /* index = 3*(T0 - T0_min) + 2 + T0_frac */
295            i = sub(T0, T0_min, pOverflow);
296            temp2 = add(i, i, pOverflow);
297            i = add(temp2, i, pOverflow);
298            temp2 = add(i, 2, pOverflow);
299            index = add(temp2, T0_frac, pOverflow);
300        }
301        else
302        {
303
304            /* encoding with 4 bit resolution */
305
306            tmp_lag = T0_prev;
307            temp1 = sub(tmp_lag, T0_min, pOverflow);
308            temp2 = sub(temp1, 5, pOverflow);
309            if (temp2 > 0)
310                tmp_lag = add(T0_min, 5, pOverflow);
311            temp1 = sub(T0_max, tmp_lag, pOverflow);
312            temp2 = sub(temp1, 4, pOverflow);
313            if (temp2 > 0)
314                tmp_lag = sub(T0_max, 4, pOverflow);
315
316            temp1 = add(T0, T0, pOverflow);
317            temp2 = add(temp1, T0, pOverflow);
318            uplag = add(temp2, T0_frac, pOverflow);
319
320            i = sub(tmp_lag, 2, pOverflow);
321            temp1 = add(i, i, pOverflow);
322            tmp_ind = add(temp1, i, pOverflow);
323
324            temp1 = sub(tmp_ind, uplag, pOverflow);
325            if (temp1 >= 0)
326            {
327                temp1 = sub(T0, tmp_lag, pOverflow);
328                index = add(temp1, 5, pOverflow);
329            }
330            else
331            {
332
333                i = add(tmp_lag, 1, pOverflow);
334                temp1 = add(i, i, pOverflow);
335                i = add(temp1, i, pOverflow);
336
337                if (sub(i, uplag, pOverflow) > 0)
338                {
339                    temp1 = sub(uplag, tmp_ind, pOverflow);
340                    index = add(temp1, 3, pOverflow);
341                }
342                else
343                {
344                    temp1 = sub(T0, tmp_lag, pOverflow);
345                    index = add(temp1, 11, pOverflow);
346                }
347            }
348
349        } /* end if (encoding with 4 bit resolution) */
350    }   /* end if (second of fourth subframe) */
351
352    return index;
353}
354
355
356
357