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 /****************************************************************************************
19 Portions 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)
26 Permission to distribute, modify and use this file under the standard license
27 terms listed above has been obtained from the copyright holder.
28 ****************************************************************************************/
29 /*
30 Pathname: ./audio/gsm-amr/c/src/q_plsf_5.c
31 Funtions:
32
33 ------------------------------------------------------------------------------
34 REVISION HISTORY
35
36 Description: Placed code in the PV standard template format.
37 Updated to accept new parameter, Flag *pOverflow.
38
39 Description:
40 Eliminated unused include files.
41 For Vq_subvec()
42 1. Eliminated math operations that unnecessary checked for
43 saturation (number are bounded to 2^12)
44 2. Eliminated access to (slow) memory by using axiliar variables
45 3. Because this routine is looking for the minimum distance,
46 introduced 3 check conditions inside the loop, so when the
47 partial distance is bigger than the minimun distance, the
48 loop is not completed and process continue with next iteration
49 For Vq_subvec_s()
50 1. Eliminated math operations that unnecessary checked for
51 saturation (number are bounded to 2^12)
52 2. Combined increasing and decreasing loops to avoid double
53 accesses to the same table element
54 3. Eliminated access to (slow) memory by using axiliar variables
55 4. Because this routine is looking for the minimum distance,
56 introduced 2 check conditions inside the loop, so when the
57 partial distance is bigger than the minimun distance, the
58 loop is not completed and process continue with next iteration
59 For Q_plsf_5()
60 1. Eliminated math operations that unnecessary checked for
61 saturation (number are bounded to 2^12)
62 2. Replaced array addressing by pointers
63
64 Description: Replaced OSCL mem type functions and eliminated include
65 files that now are chosen by OSCL definitions
66
67 Description: Replaced "int" and/or "char" with OSCL defined types.
68
69
70 Description: Added #ifdef __cplusplus around extern'ed table.
71
72 Who: Date:
73 Description:
74
75 ------------------------------------------------------------------------------
76 MODULE DESCRIPTION
77
78
79 ------------------------------------------------------------------------------
80 */
81
82 /*----------------------------------------------------------------------------
83 ; INCLUDES
84 ----------------------------------------------------------------------------*/
85 #include "q_plsf.h"
86 #include "typedef.h"
87 #include "basic_op.h"
88 #include "lsp_lsf.h"
89 #include "reorder.h"
90 #include "lsfwt.h"
91
92 /*--------------------------------------------------------------------------*/
93 #ifdef __cplusplus
94 extern "C"
95 {
96 #endif
97
98 /*----------------------------------------------------------------------------
99 ; MACROS
100 ; Define module specific macros here
101 ----------------------------------------------------------------------------*/
102
103 /*----------------------------------------------------------------------------
104 ; DEFINES
105 ; Include all pre-processor statements here. Include conditional
106 ; compile variables also.
107 ----------------------------------------------------------------------------*/
108
109 /*----------------------------------------------------------------------------
110 ; LOCAL FUNCTION DEFINITIONS
111 ; Function Prototype declaration
112 ----------------------------------------------------------------------------*/
113
114 /*----------------------------------------------------------------------------
115 ; LOCAL VARIABLE DEFINITIONS
116 ; Variable declaration - defined here and used outside this module
117 ----------------------------------------------------------------------------*/
118
119 /*----------------------------------------------------------------------------
120 ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
121 ; Declare variables used in this module but defined elsewhere
122 ----------------------------------------------------------------------------*/
123 /* Codebooks of LSF prediction residual */
124 extern const Word16 mean_lsf_5[];
125
126 extern const Word16 dico1_lsf_5[];
127 extern const Word16 dico2_lsf_5[];
128 extern const Word16 dico3_lsf_5[];
129 extern const Word16 dico4_lsf_5[];
130 extern const Word16 dico5_lsf_5[];
131
132 /*--------------------------------------------------------------------------*/
133 #ifdef __cplusplus
134 }
135 #endif
136
137 /*
138 ------------------------------------------------------------------------------
139 FUNCTION NAME: Vq_subvec
140 ------------------------------------------------------------------------------
141 INPUT AND OUTPUT DEFINITIONS
142
143 Inputs:
144 lsf_r1 -- array of type Word16 -- 1st LSF residual vector, Q15
145 lsf_r2 -- array of type Word16 -- 2nd LSF residual vector, Q15
146 dico -- pointer to const Word16 -- quantization codebook, Q15
147 wf1 -- array of type Word16 -- 1st LSF weighting factors, Q13
148 wf2 -- array of type Word16 -- 2nd LSF weighting factors, Q13
149 dico_size -- Word16 -- size of quantization codebook, Q0
150 Outputs:
151 pOverflow -- pointer to type Flag -- overflow indicator
152
153 Returns:
154 Word16 -- quantization index, Q0
155
156 Global Variables Used:
157 None
158
159 Local Variables Needed:
160 None
161
162 ------------------------------------------------------------------------------
163 FUNCTION DESCRIPTION
164
165 This function performs the quantization of a 4-dimensional subvector.
166
167 ------------------------------------------------------------------------------
168 REQUIREMENTS
169
170 None
171
172 ------------------------------------------------------------------------------
173 REFERENCES
174
175 q_plsf_5.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
176
177 ------------------------------------------------------------------------------
178 PSEUDO-CODE
179
180
181 ------------------------------------------------------------------------------
182 RESOURCES USED [optional]
183
184 When the code is written for a specific target processor the
185 the resources used should be documented below.
186
187 HEAP MEMORY USED: x bytes
188
189 STACK MEMORY USED: x bytes
190
191 CLOCK CYCLES: (cycle count equation for this function) + (variable
192 used to represent cycle count for each subroutine
193 called)
194 where: (cycle count variable) = cycle count for [subroutine
195 name]
196
197 ------------------------------------------------------------------------------
198 CAUTION [optional]
199 [State any special notes, constraints or cautions for users of this function]
200
201 ------------------------------------------------------------------------------
202 */
203 /* Quantization of a 4 dimensional subvector */
204
Vq_subvec(Word16 * lsf_r1,Word16 * lsf_r2,const Word16 * dico,Word16 * wf1,Word16 * wf2,Word16 dico_size,Flag * pOverflow)205 static Word16 Vq_subvec( /* o : quantization index, Q0 */
206 Word16 *lsf_r1, /* i : 1st LSF residual vector, Q15 */
207 Word16 *lsf_r2, /* i : 2nd LSF residual vector, Q15 */
208 const Word16 *dico, /* i : quantization codebook, Q15 */
209 Word16 *wf1, /* i : 1st LSF weighting factors Q13 */
210 Word16 *wf2, /* i : 2nd LSF weighting factors Q13 */
211 Word16 dico_size, /* i : size of quantization codebook, Q0 */
212 Flag *pOverflow /* o : overflow indicator */
213 )
214 {
215 Word16 index = 0; /* initialization only needed to keep gcc silent */
216 Word16 i;
217 Word16 temp;
218 const Word16 *p_dico;
219 Word32 dist_min;
220 Word32 dist;
221 Word16 wf1_0;
222 Word16 wf1_1;
223 Word16 wf2_0;
224 Word16 wf2_1;
225 Word32 aux1;
226 Word32 aux2;
227 Word32 aux3;
228 Word32 aux4;
229
230 OSCL_UNUSED_ARG(pOverflow);
231
232 dist_min = MAX_32;
233 p_dico = dico;
234
235 wf1_0 = wf1[0];
236 wf1_1 = wf1[1];
237 wf2_0 = wf2[0];
238 wf2_1 = wf2[1];
239
240 aux1 = ((Word32) lsf_r1[0] * wf1_0);
241 aux2 = ((Word32) lsf_r1[1] * wf1_1);
242 aux3 = ((Word32) lsf_r2[0] * wf2_0);
243 aux4 = ((Word32) lsf_r2[1] * wf2_1);
244
245 for (i = 0; i < dico_size; i++)
246 {
247 temp = (aux1 - ((Word32)wf1_0 * *(p_dico++))) >> 15;
248 dist = ((Word32)temp * temp);
249
250 if (dist >= dist_min)
251 {
252 p_dico += 3;
253 continue;
254 }
255
256 temp = (aux2 - ((Word32)wf1_1 * *(p_dico++))) >> 15;
257 dist += ((Word32)temp * temp);
258
259 if (dist >= dist_min)
260 {
261 p_dico += 2;
262 continue;
263 }
264
265 temp = (aux3 - ((Word32)wf2_0 * *(p_dico++))) >> 15;
266 dist += ((Word32)temp * temp);
267
268 if (dist >= dist_min)
269 {
270 p_dico += 1;
271 continue;
272 }
273
274 temp = (aux4 - ((Word32)wf2_1 * *(p_dico++))) >> 15;
275 dist += ((Word32)temp * temp);
276
277
278 if (dist < dist_min)
279 {
280 dist_min = dist;
281 index = i;
282 }
283 }
284
285
286
287 /* Reading the selected vector */
288
289 p_dico = &dico[ index<<2];
290 lsf_r1[0] = *p_dico++;
291 lsf_r1[1] = *p_dico++;
292 lsf_r2[0] = *p_dico++;
293 lsf_r2[1] = *p_dico;
294
295 return index;
296
297 }
298
299
300 /*
301 ------------------------------------------------------------------------------
302 FUNCTION NAME: Vq_subvec_s
303 ------------------------------------------------------------------------------
304 INPUT AND OUTPUT DEFINITIONS
305
306 Inputs:
307 lsf_r1 -- array of type Word16 -- 1st LSF residual vector, Q15
308 lsf_r2 -- array of type Word16 -- 2nd LSF residual vector, Q15
309 dico -- pointer to const Word16 -- quantization codebook, Q15
310 wf1 -- array of type Word16 -- 1st LSF weighting factors, Q13
311 wf2 -- array of type Word16 -- 2nd LSF weighting factors, Q13
312 dico_size -- Word16 -- size of quantization codebook, Q0
313
314 Outputs:
315 pOverflow -- pointer to type Flag -- overflow indicator
316
317 Returns:
318 Word16 -- quantization index, Q0
319
320 Global Variables Used:
321 None
322
323 Local Variables Needed:
324 None
325
326 ------------------------------------------------------------------------------
327 FUNCTION DESCRIPTION
328
329 This function performs the quantization of a 4-dimensional subvector.
330
331 ------------------------------------------------------------------------------
332 REQUIREMENTS
333
334 None
335
336 ------------------------------------------------------------------------------
337 REFERENCES
338
339 q_plsf_5.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
340
341 ------------------------------------------------------------------------------
342 PSEUDO-CODE
343
344
345 ------------------------------------------------------------------------------
346 RESOURCES USED [optional]
347
348 When the code is written for a specific target processor the
349 the resources used should be documented below.
350
351 HEAP MEMORY USED: x bytes
352
353 STACK MEMORY USED: x bytes
354
355 CLOCK CYCLES: (cycle count equation for this function) + (variable
356 used to represent cycle count for each subroutine
357 called)
358 where: (cycle count variable) = cycle count for [subroutine
359 name]
360
361 ------------------------------------------------------------------------------
362 CAUTION [optional]
363 [State any special notes, constraints or cautions for users of this function]
364
365 ------------------------------------------------------------------------------
366 */
367
368
369 /* Quantization of a 4 dimensional subvector with a signed codebook */
370
Vq_subvec_s(Word16 * lsf_r1,Word16 * lsf_r2,const Word16 * dico,Word16 * wf1,Word16 * wf2,Word16 dico_size,Flag * pOverflow)371 static Word16 Vq_subvec_s( /* o : quantization index Q0 */
372 Word16 *lsf_r1, /* i : 1st LSF residual vector Q15 */
373 Word16 *lsf_r2, /* i : and LSF residual vector Q15 */
374 const Word16 *dico, /* i : quantization codebook Q15 */
375 Word16 *wf1, /* i : 1st LSF weighting factors Q13 */
376 Word16 *wf2, /* i : 2nd LSF weighting factors Q13 */
377 Word16 dico_size, /* i : size of quantization codebook Q0 */
378 Flag *pOverflow) /* o : overflow indicator */
379 {
380 Word16 index = 0; /* initialization only needed to keep gcc silent */
381 Word16 sign = 0; /* initialization only needed to keep gcc silent */
382 Word16 i;
383 Word16 temp;
384 Word16 temp1;
385 Word16 temp2;
386 const Word16 *p_dico;
387 Word32 dist_min;
388 Word32 dist1;
389 Word32 dist2;
390
391 Word16 lsf_r1_0;
392 Word16 lsf_r1_1;
393 Word16 lsf_r2_0;
394 Word16 lsf_r2_1;
395
396 Word16 wf1_0;
397 Word16 wf1_1;
398 Word16 wf2_0;
399 Word16 wf2_1;
400
401 OSCL_UNUSED_ARG(pOverflow);
402
403 dist_min = MAX_32;
404 p_dico = dico;
405
406
407 lsf_r1_0 = lsf_r1[0];
408 lsf_r1_1 = lsf_r1[1];
409 lsf_r2_0 = lsf_r2[0];
410 lsf_r2_1 = lsf_r2[1];
411
412 wf1_0 = wf1[0];
413 wf1_1 = wf1[1];
414 wf2_0 = wf2[0];
415 wf2_1 = wf2[1];
416
417 for (i = 0; i < dico_size; i++)
418 {
419 /* test positive */
420 temp = *p_dico++;
421 temp1 = lsf_r1_0 - temp;
422 temp2 = lsf_r1_0 + temp;
423 temp1 = ((Word32)wf1_0 * temp1) >> 15;
424 temp2 = ((Word32)wf1_0 * temp2) >> 15;
425 dist1 = ((Word32)temp1 * temp1);
426 dist2 = ((Word32)temp2 * temp2);
427
428 temp = *p_dico++;
429 temp1 = lsf_r1_1 - temp;
430 temp2 = lsf_r1_1 + temp;
431 temp1 = ((Word32)wf1_1 * temp1) >> 15;
432 temp2 = ((Word32)wf1_1 * temp2) >> 15;
433 dist1 += ((Word32)temp1 * temp1);
434 dist2 += ((Word32)temp2 * temp2);
435
436 if ((dist1 >= dist_min) && (dist2 >= dist_min))
437 {
438 p_dico += 2;
439 continue;
440 }
441
442 temp = *p_dico++;
443 temp1 = lsf_r2_0 - temp;
444 temp2 = lsf_r2_0 + temp;
445 temp1 = ((Word32)wf2_0 * temp1) >> 15;
446 temp2 = ((Word32)wf2_0 * temp2) >> 15;
447 dist1 += ((Word32)temp1 * temp1);
448 dist2 += ((Word32)temp2 * temp2);
449
450 temp = *p_dico++;
451 temp1 = lsf_r2_1 - temp;
452 temp2 = lsf_r2_1 + temp;
453 temp1 = ((Word32)wf2_1 * temp1) >> 15;
454 temp2 = ((Word32)wf2_1 * temp2) >> 15;
455 dist1 += ((Word32)temp1 * temp1);
456 dist2 += ((Word32)temp2 * temp2);
457
458 if (dist1 < dist_min)
459 {
460 dist_min = dist1;
461 index = i;
462 sign = 0;
463 }
464
465 /* test negative */
466
467 if (dist2 < dist_min)
468 {
469 dist_min = dist2;
470 index = i;
471 sign = 1;
472 }
473 }
474
475 /* Reading the selected vector */
476
477 p_dico = &dico[index<<2];
478 index <<= 1;
479 if (sign)
480 {
481 lsf_r1[0] = - (*p_dico++);
482 lsf_r1[1] = - (*p_dico++);
483 lsf_r2[0] = - (*p_dico++);
484 lsf_r2[1] = - (*p_dico);
485 index += 1;
486 }
487 else
488 {
489 lsf_r1[0] = *p_dico++;
490 lsf_r1[1] = *p_dico++;
491 lsf_r2[0] = *p_dico++;
492 lsf_r2[1] = *p_dico;
493 }
494
495 return index;
496
497 }
498
499 /*
500 ------------------------------------------------------------------------------
501 FUNCTION NAME: Q_plsf_5
502 ------------------------------------------------------------------------------
503 INPUT AND OUTPUT DEFINITIONS
504
505
506 Inputs:
507 st -- pointer to Q_plsfState -- state information
508 lsp1 -- array of type Word16 -- 1st LSP vector, Q15
509 lsp2 -- array of type Word16 -- 2nd LSP vector, Q15
510
511 Outputs:
512 lps1_q -- array of type Word16 -- quantized 1st LSP vector, Q15
513 lps2_q -- array of type Word16 -- quantized 2nd LSP vector, Q15
514 indices -- array of type Word16 -- quantization indices of 5 matrics, Q0
515 pOverflow -- pointer to type Flag -- overflow indicator
516
517 Returns:
518 None
519
520 Global Variables Used:
521 mean_lsf_5[];
522
523 dico1_lsf_5[];
524 dico2_lsf_5[];
525 dico3_lsf_5[];
526 dico4_lsf_5[];
527 dico5_lsf_5[];
528
529 Local Variables Needed:
530 None
531
532 ------------------------------------------------------------------------------
533 FUNCTION DESCRIPTION
534
535 PURPOSE: Quantization of 2 sets of LSF parameters using 1st order MA
536 prediction and split by 5 matrix quantization (split-MQ)
537
538 DESCRIPTION:
539
540 p[i] = pred_factor*past_rq[i]; i=0,...,m-1
541 r1[i]= lsf1[i] - p[i]; i=0,...,m-1
542 r2[i]= lsf2[i] - p[i]; i=0,...,m-1
543 where:
544 lsf1[i] 1st mean-removed LSF vector.
545 lsf2[i] 2nd mean-removed LSF vector.
546 r1[i] 1st residual prediction vector.
547 r2[i] 2nd residual prediction vector.
548 past_r2q[i] Past quantized residual (2nd vector).
549
550 The residual vectors r1[i] and r2[i] are jointly quantized using
551 split-MQ with 5 codebooks. Each 4th dimension submatrix contains 2
552 elements from each residual vector. The 5 submatrices are as follows:
553 {r1[0], r1[1], r2[0], r2[1]}; {r1[2], r1[3], r2[2], r2[3]};
554 {r1[4], r1[5], r2[4], r2[5]}; {r1[6], r1[7], r2[6], r2[7]};
555 {r1[8], r1[9], r2[8], r2[9]}
556
557 ------------------------------------------------------------------------------
558 REQUIREMENTS
559
560 None
561
562 ------------------------------------------------------------------------------
563 REFERENCES
564
565 q_plsf_5.c, UMTS GSM AMR speech codec, R99 - Version 3.2.0, March 2, 2001
566
567 ------------------------------------------------------------------------------
568 PSEUDO-CODE
569
570
571 ------------------------------------------------------------------------------
572 RESOURCES USED [optional]
573
574 When the code is written for a specific target processor the
575 the resources used should be documented below.
576
577 HEAP MEMORY USED: x bytes
578
579 STACK MEMORY USED: x bytes
580
581 CLOCK CYCLES: (cycle count equation for this function) + (variable
582 used to represent cycle count for each subroutine
583 called)
584 where: (cycle count variable) = cycle count for [subroutine
585 name]
586
587 ------------------------------------------------------------------------------
588 CAUTION [optional]
589 [State any special notes, constraints or cautions for users of this function]
590
591 ------------------------------------------------------------------------------
592 */
593
Q_plsf_5(Q_plsfState * st,Word16 * lsp1,Word16 * lsp2,Word16 * lsp1_q,Word16 * lsp2_q,Word16 * indice,Flag * pOverflow)594 void Q_plsf_5(
595 Q_plsfState *st,
596 Word16 *lsp1, /* i : 1st LSP vector, Q15 */
597 Word16 *lsp2, /* i : 2nd LSP vector, Q15 */
598 Word16 *lsp1_q, /* o : quantized 1st LSP vector, Q15 */
599 Word16 *lsp2_q, /* o : quantized 2nd LSP vector, Q15 */
600 Word16 *indice, /* o : quantization indices of 5 matrices, Q0 */
601 Flag *pOverflow /* o : overflow indicator */
602 )
603 {
604 Word16 i;
605 Word16 lsf1[M];
606 Word16 lsf2[M];
607 Word16 wf1[M];
608 Word16 wf2[M];
609 Word16 lsf_p[M];
610 Word16 lsf_r1[M];
611 Word16 lsf_r2[M];
612 Word16 lsf1_q[M];
613 Word16 lsf2_q[M];
614
615 Word16 *p_lsf_p;
616 Word16 *p_lsf1;
617 Word16 *p_lsf2;
618 Word16 *p_lsf_r1;
619 Word16 *p_lsf_r2;
620
621 /* convert LSFs to normalize frequency domain 0..16384 */
622
623 Lsp_lsf(lsp1, lsf1, M, pOverflow);
624 Lsp_lsf(lsp2, lsf2, M, pOverflow);
625
626 /* Compute LSF weighting factors (Q13) */
627
628 Lsf_wt(lsf1, wf1, pOverflow);
629 Lsf_wt(lsf2, wf2, pOverflow);
630
631 /* Compute predicted LSF and prediction error */
632
633 p_lsf_p = &lsf_p[0];
634 p_lsf1 = &lsf1[0];
635 p_lsf2 = &lsf2[0];
636 p_lsf_r1 = &lsf_r1[0];
637 p_lsf_r2 = &lsf_r2[0];
638
639 for (i = 0; i < M; i++)
640 {
641 *(p_lsf_p) = mean_lsf_5[i] +
642 (((Word32)st->past_rq[i] * LSP_PRED_FAC_MR122) >> 15);
643
644 *(p_lsf_r1++) = *(p_lsf1++) - *(p_lsf_p);
645 *(p_lsf_r2++) = *(p_lsf2++) - *(p_lsf_p++);
646 }
647
648 /*---- Split-MQ of prediction error ----*/
649
650 indice[0] = Vq_subvec(&lsf_r1[0], &lsf_r2[0], dico1_lsf_5,
651 &wf1[0], &wf2[0], DICO1_5_SIZE, pOverflow);
652
653 indice[1] = Vq_subvec(&lsf_r1[2], &lsf_r2[2], dico2_lsf_5,
654 &wf1[2], &wf2[2], DICO2_5_SIZE, pOverflow);
655
656 indice[2] = Vq_subvec_s(&lsf_r1[4], &lsf_r2[4], dico3_lsf_5,
657 &wf1[4], &wf2[4], DICO3_5_SIZE, pOverflow);
658
659 indice[3] = Vq_subvec(&lsf_r1[6], &lsf_r2[6], dico4_lsf_5,
660 &wf1[6], &wf2[6], DICO4_5_SIZE, pOverflow);
661
662 indice[4] = Vq_subvec(&lsf_r1[8], &lsf_r2[8], dico5_lsf_5,
663 &wf1[8], &wf2[8], DICO5_5_SIZE, pOverflow);
664
665 /* Compute quantized LSFs and update the past quantized residual */
666
667 p_lsf_r1 = &lsf_r1[0];
668 p_lsf_r2 = &lsf_r2[0];
669 p_lsf_p = &lsf_p[0];
670 p_lsf1 = &lsf1_q[0];
671 p_lsf2 = &lsf2_q[0];
672
673
674 for (i = 0; i < M; i++)
675 {
676 *(p_lsf1++) = *(p_lsf_r1++) + *(p_lsf_p);
677 *(p_lsf2++) = *(p_lsf_r2) + *(p_lsf_p++);
678 st->past_rq[i] = *(p_lsf_r2++);
679 }
680
681 /* verification that LSFs has minimum distance of LSF_GAP */
682
683 Reorder_lsf(lsf1_q, LSF_GAP, M, pOverflow);
684 Reorder_lsf(lsf2_q, LSF_GAP, M, pOverflow);
685
686 /* convert LSFs to the cosine domain */
687
688 Lsf_lsp(lsf1_q, lsp1_q, M, pOverflow);
689 Lsf_lsp(lsf2_q, lsp2_q, M, pOverflow);
690 }
691
692