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 Pathname: ./audio/gsm-amr/c/src/lsp.c
31 Functions:
32
33------------------------------------------------------------------------------
34 REVISION HISTORY
35
36 Description: Updated template used to PV coding template.
37 Changed to accept the pOverflow flag for EPOC compatibility.
38
39 Description: Per review comments, added pOverflow flag to a few forgotten
40 functions.  Removed unnecessary include files.
41
42 Description:  For lsp_reset() and lsp()
43              1. Replaced copy() with more efficient memcpy().
44              2. Eliminated unused include file copy.h.
45
46 Description:  For lsp_reset()
47              1. Modified memcpy() operands order.
48
49 Description:  Replaced OSCL mem type functions and eliminated include
50               files that now are chosen by OSCL definitions
51
52 Description:  Replaced "int" and/or "char" with OSCL defined types.
53
54 Who:                           Date:
55 Description:
56
57------------------------------------------------------------------------------
58 MODULE DESCRIPTION
59
60
61------------------------------------------------------------------------------
62*/
63
64/*----------------------------------------------------------------------------
65; INCLUDES
66----------------------------------------------------------------------------*/
67#include <stdlib.h>
68#include <string.h>
69
70#include "lsp.h"
71#include "typedef.h"
72#include "q_plsf.h"
73#include "az_lsp.h"
74#include "int_lpc.h"
75#include "lsp_tab.h"
76
77/*----------------------------------------------------------------------------
78; MACROS
79; Define module specific macros here
80----------------------------------------------------------------------------*/
81
82/*----------------------------------------------------------------------------
83; DEFINES
84; Include all pre-processor statements here. Include conditional
85; compile variables also.
86----------------------------------------------------------------------------*/
87
88/*----------------------------------------------------------------------------
89; LOCAL FUNCTION DEFINITIONS
90; Function Prototype declaration
91----------------------------------------------------------------------------*/
92
93/*----------------------------------------------------------------------------
94; LOCAL VARIABLE DEFINITIONS
95; Variable declaration - defined here and used outside this module
96----------------------------------------------------------------------------*/
97
98
99/*
100------------------------------------------------------------------------------
101 FUNCTION NAME: lsp_init (lspState **st)
102------------------------------------------------------------------------------
103 INPUT AND OUTPUT DEFINITIONS
104
105 Inputs:
106    st = Pointer to type lspState
107
108 Outputs:
109    st = Pointer to type lspState -- values are initialized.
110
111 Returns:
112    None
113
114 Global Variables Used:
115    lsp_init_data = Word16 array.
116
117
118 Local Variables Needed:
119    None
120
121------------------------------------------------------------------------------
122 FUNCTION DESCRIPTION
123
124    Initializes lsp state data.
125
126------------------------------------------------------------------------------
127 REQUIREMENTS
128
129 None
130
131------------------------------------------------------------------------------
132 REFERENCES
133
134 lsp.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
135
136------------------------------------------------------------------------------
137 PSEUDO-CODE
138
139
140------------------------------------------------------------------------------
141 RESOURCES USED [optional]
142
143 When the code is written for a specific target processor the
144 the resources used should be documented below.
145
146 HEAP MEMORY USED: x bytes
147
148 STACK MEMORY USED: x bytes
149
150 CLOCK CYCLES: (cycle count equation for this function) + (variable
151                used to represent cycle count for each subroutine
152                called)
153     where: (cycle count variable) = cycle count for [subroutine
154                                     name]
155
156------------------------------------------------------------------------------
157 CAUTION [optional]
158 [State any special notes, constraints or cautions for users of this function]
159
160------------------------------------------------------------------------------
161*/
162
163Word16 lsp_init(lspState **st)
164{
165    lspState* s;
166
167    if (st == (lspState **) NULL)
168    {
169        /* fprintf(stderr, "lsp_init: invalid parameter\n"); */
170        return -1;
171    }
172
173    *st = NULL;
174
175    /* allocate memory */
176    if ((s = (lspState *) malloc(sizeof(lspState))) == NULL)
177    {
178        /* fprintf(stderr, "lsp_init: can not malloc state structure\n"); */
179        return -1;
180    }
181
182    /* Initialize quantization state */
183    if (0 != Q_plsf_init(&s->qSt))
184    {
185        return -1;
186    }
187
188    if (0 != lsp_reset(s))
189    {
190        return -1;
191    }
192
193    *st = s;
194
195    return 0;
196}
197
198
199
200
201
202/*
203------------------------------------------------------------------------------
204 FUNCTION NAME: lsp_reset
205------------------------------------------------------------------------------
206 INPUT AND OUTPUT DEFINITIONS
207
208 Inputs:
209    st = Pointer to type lspState
210
211 Outputs:
212    st = Pointer to type lspState -- values are reset.
213
214 Returns:
215    None
216
217 Global Variables Used:
218    None
219
220 Local Variables Needed:
221    None
222
223------------------------------------------------------------------------------
224 FUNCTION DESCRIPTION
225
226    resets lsp_state data
227------------------------------------------------------------------------------
228 REQUIREMENTS
229
230 None
231
232------------------------------------------------------------------------------
233 REFERENCES
234
235 lsp.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
236
237------------------------------------------------------------------------------
238 PSEUDO-CODE
239
240
241------------------------------------------------------------------------------
242 RESOURCES USED [optional]
243
244 When the code is written for a specific target processor the
245 the resources used should be documented below.
246
247 HEAP MEMORY USED: x bytes
248
249 STACK MEMORY USED: x bytes
250
251 CLOCK CYCLES: (cycle count equation for this function) + (variable
252                used to represent cycle count for each subroutine
253                called)
254     where: (cycle count variable) = cycle count for [subroutine
255                                     name]
256
257------------------------------------------------------------------------------
258 CAUTION [optional]
259 [State any special notes, constraints or cautions for users of this function]
260
261------------------------------------------------------------------------------
262*/
263Word16 lsp_reset(lspState *st)
264{
265
266    if (st == (lspState *) NULL)
267    {
268        /* fprintf(stderr, "lsp_reset: invalid parameter\n"); */
269        return -1;
270    }
271
272    /* Init lsp_old[] */
273    memcpy(st->lsp_old,   lsp_init_data,   M*sizeof(Word16));
274
275    /* Initialize lsp_old_q[] */
276    memcpy(st->lsp_old_q,   st->lsp_old,  M*sizeof(Word16));
277
278    /* Reset quantization state */
279    Q_plsf_reset(st->qSt);
280
281    return 0;
282}
283
284
285
286
287
288
289
290/*
291------------------------------------------------------------------------------
292 FUNCTION NAME: lsp_exit
293------------------------------------------------------------------------------
294 INPUT AND OUTPUT DEFINITIONS
295
296 Inputs:
297    st = Pointer to type lspState
298
299 Outputs:
300    None
301
302 Returns:
303    None
304
305 Global Variables Used:
306    None
307
308 Local Variables Needed:
309    None
310
311------------------------------------------------------------------------------
312 FUNCTION DESCRIPTION
313
314    Frees memory used by lspState.
315
316------------------------------------------------------------------------------
317 REQUIREMENTS
318
319 None
320
321------------------------------------------------------------------------------
322 REFERENCES
323
324 lsp.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
325
326------------------------------------------------------------------------------
327 PSEUDO-CODE
328
329
330------------------------------------------------------------------------------
331 RESOURCES USED [optional]
332
333 When the code is written for a specific target processor the
334 the resources used should be documented below.
335
336 HEAP MEMORY USED: x bytes
337
338 STACK MEMORY USED: x bytes
339
340 CLOCK CYCLES: (cycle count equation for this function) + (variable
341                used to represent cycle count for each subroutine
342                called)
343     where: (cycle count variable) = cycle count for [subroutine
344                                     name]
345
346------------------------------------------------------------------------------
347 CAUTION [optional]
348 [State any special notes, constraints or cautions for users of this function]
349
350------------------------------------------------------------------------------
351*/
352void lsp_exit(lspState **st)
353{
354    if (st == NULL || *st == NULL)
355        return;
356
357    /* Deallocate members */
358    Q_plsf_exit(&(*st)->qSt);
359
360    /* deallocate memory */
361    free(*st);
362    *st = NULL;
363
364    return;
365}
366
367
368
369/*
370------------------------------------------------------------------------------
371 FUNCTION NAME: lsp
372------------------------------------------------------------------------------
373 INPUT AND OUTPUT DEFINITIONS
374
375
376
377 Inputs:
378    st = Pointer to type lspState -- State struct
379    req_mode = enum Mode -- requested coder mode
380    used_mode = enum Mode -- used coder mode
381    az = array of type Word16 -- interpolated LP parameters Q12
382
383 Outputs:
384    azQ = array of type Word16 -- quantization interpol. LP parameters Q12
385    lsp_new = array of type Word16 -- new lsp vector
386    anap = Double pointer of type Word16 -- analysis parameters
387    pOverflow = Pointer to type Flag -- Flag set when overflow occurs
388    st = Pointer to type lspState -- State struct
389    az = array of type Word16 -- interpolated LP parameters Q12
390
391 Returns:
392    None
393
394 Global Variables Used:
395    None
396
397 Local Variables Needed:
398    None
399
400------------------------------------------------------------------------------
401 FUNCTION DESCRIPTION
402
403
404------------------------------------------------------------------------------
405 REQUIREMENTS
406
407 None
408
409------------------------------------------------------------------------------
410 REFERENCES
411
412 lsp.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
413
414------------------------------------------------------------------------------
415 PSEUDO-CODE
416
417
418------------------------------------------------------------------------------
419 RESOURCES USED [optional]
420
421 When the code is written for a specific target processor the
422 the resources used should be documented below.
423
424 HEAP MEMORY USED: x bytes
425
426 STACK MEMORY USED: x bytes
427
428 CLOCK CYCLES: (cycle count equation for this function) + (variable
429                used to represent cycle count for each subroutine
430                called)
431     where: (cycle count variable) = cycle count for [subroutine
432                                     name]
433
434------------------------------------------------------------------------------
435 CAUTION [optional]
436 [State any special notes, constraints or cautions for users of this function]
437
438------------------------------------------------------------------------------
439*/
440void lsp(lspState *st,       /* i/o : State struct                            */
441         enum Mode req_mode, /* i   : requested coder mode                    */
442         enum Mode used_mode,/* i   : used coder mode                         */
443         Word16 az[],        /* i/o : interpolated LP parameters Q12          */
444         Word16 azQ[],       /* o   : quantization interpol. LP parameters Q12*/
445         Word16 lsp_new[],   /* o   : new lsp vector                          */
446         Word16 **anap,      /* o   : analysis parameters                     */
447         Flag   *pOverflow)  /* o   : Flag set when overflow occurs           */
448
449{
450    Word16 lsp_new_q[M];    /* LSPs at 4th subframe           */
451    Word16 lsp_mid[M], lsp_mid_q[M];    /* LSPs at 2nd subframe           */
452
453    Word16 pred_init_i; /* init index for MA prediction in DTX mode */
454
455    if (req_mode == MR122)
456    {
457        Az_lsp(&az[MP1], lsp_mid, st->lsp_old, pOverflow);
458        Az_lsp(&az[MP1 * 3], lsp_new, lsp_mid, pOverflow);
459
460        /*--------------------------------------------------------------------*
461         * Find interpolated LPC parameters in all subframes (both quantized  *
462         * and unquantized).                                                  *
463         * The interpolated parameters are in array A_t[] of size (M+1)*4     *
464         * and the quantized interpolated parameters are in array Aq_t[]      *
465         *--------------------------------------------------------------------*/
466        Int_lpc_1and3_2(st->lsp_old, lsp_mid, lsp_new, az, pOverflow);
467
468        if (used_mode != MRDTX)
469        {
470            /* LSP quantization (lsp_mid[] and lsp_new[] jointly quantized) */
471            Q_plsf_5(
472                st->qSt,
473                lsp_mid,
474                lsp_new,
475                lsp_mid_q,
476                lsp_new_q,
477                *anap,
478                pOverflow);
479
480            Int_lpc_1and3(st->lsp_old_q, lsp_mid_q, lsp_new_q, azQ, pOverflow);
481
482            /* Advance analysis parameters pointer */
483            (*anap) += 5;
484        }
485    }
486    else
487    {
488        Az_lsp(&az[MP1 * 3], lsp_new, st->lsp_old, pOverflow);  /* From A(z) to lsp  */
489
490        /*--------------------------------------------------------------------*
491         * Find interpolated LPC parameters in all subframes (both quantized  *
492         * and unquantized).                                                  *
493         * The interpolated parameters are in array A_t[] of size (M+1)*4     *
494         * and the quantized interpolated parameters are in array Aq_t[]      *
495         *--------------------------------------------------------------------*/
496
497        Int_lpc_1to3_2(st->lsp_old, lsp_new, az, pOverflow);
498
499        if (used_mode != MRDTX)
500        {
501            /* LSP quantization */
502            Q_plsf_3(
503                st->qSt,
504                req_mode,
505                lsp_new,
506                lsp_new_q,
507                *anap,
508                &pred_init_i,
509                pOverflow);
510
511            Int_lpc_1to3(
512                st->lsp_old_q,
513                lsp_new_q,
514                azQ,
515                pOverflow);
516
517            /* Advance analysis parameters pointer */
518            (*anap) += 3;
519        }
520    }
521
522    /* update the LSPs for the next frame */
523    memcpy(st->lsp_old,   lsp_new,   M*sizeof(Word16));
524
525    if (used_mode != MRDTX)
526    {
527        memcpy(st->lsp_old_q, lsp_new_q, M*sizeof(Word16));
528    }
529}
530
531