Mercurial > libavcodec.hg
annotate lsp.c @ 12494:94eaea836bf4 libavcodec
Check avctx width/height more thoroughly (e.g. all values 0 except width would
have been accepted before).
Also do not fail if they are invalid but instead override them to 0.
This allows decoding e.g. MPEG video when only the container values are corrupted.
For encoding a value of 0,0 of course makes no sense, but was allowed
through before and will be caught by an extra check in the encode function.
author | reimar |
---|---|
date | Wed, 15 Sep 2010 04:46:55 +0000 |
parents | 1921e24d5886 |
children |
rev | line source |
---|---|
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
1 /* |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
2 * LSP routines for ACELP-based codecs |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
3 * |
10011
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
4 * Copyright (c) 2007 Reynaldo H. Verdejo Pinochet (QCELP decoder) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
5 * Copyright (c) 2008 Vladimir Voroshilov |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
6 * |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
7 * This file is part of FFmpeg. |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
8 * |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
9 * FFmpeg is free software; you can redistribute it and/or |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
10 * modify it under the terms of the GNU Lesser General Public |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
11 * License as published by the Free Software Foundation; either |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
12 * version 2.1 of the License, or (at your option) any later version. |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
13 * |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
14 * FFmpeg is distributed in the hope that it will be useful, |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
17 * Lesser General Public License for more details. |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
18 * |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
19 * You should have received a copy of the GNU Lesser General Public |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
20 * License along with FFmpeg; if not, write to the Free Software |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
22 */ |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
23 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
24 #include <inttypes.h> |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
25 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
26 #include "avcodec.h" |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
27 #define FRAC_BITS 14 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
28 #include "mathops.h" |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
29 #include "lsp.h" |
8048
ecb1962c12f3
Rename acelp_math.[ch] to celp_math.[ch] to prepare for QCELP decoder merge.
diego
parents:
7697
diff
changeset
|
30 #include "celp_math.h" |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
31 |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
32 void ff_acelp_reorder_lsf(int16_t* lsfq, int lsfq_min_distance, int lsfq_min, int lsfq_max, int lp_order) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
33 { |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
34 int i, j; |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
35 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
36 /* sort lsfq in ascending order. float bubble agorithm, |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
37 O(n) if data already sorted, O(n^2) - otherwise */ |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
38 for(i=0; i<lp_order-1; i++) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
39 for(j=i; j>=0 && lsfq[j] > lsfq[j+1]; j--) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
40 FFSWAP(int16_t, lsfq[j], lsfq[j+1]); |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
41 |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
42 for(i=0; i<lp_order; i++) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
43 { |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
44 lsfq[i] = FFMAX(lsfq[i], lsfq_min); |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
45 lsfq_min = lsfq[i] + lsfq_min_distance; |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
46 } |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
47 lsfq[lp_order-1] = FFMIN(lsfq[lp_order-1], lsfq_max);//Is warning required ? |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
48 } |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
49 |
10517
5317dff91b48
Use doubles in ff_set_min_dist_lsf(). After this patch, AMR can use this
vitor
parents:
10506
diff
changeset
|
50 void ff_set_min_dist_lsf(float *lsf, double min_spacing, int size) |
10463
9f35b262d3f0
Commit some functions that are used by both SIPR and AMR.
vitor
parents:
10011
diff
changeset
|
51 { |
9f35b262d3f0
Commit some functions that are used by both SIPR and AMR.
vitor
parents:
10011
diff
changeset
|
52 int i; |
9f35b262d3f0
Commit some functions that are used by both SIPR and AMR.
vitor
parents:
10011
diff
changeset
|
53 float prev = 0.0; |
9f35b262d3f0
Commit some functions that are used by both SIPR and AMR.
vitor
parents:
10011
diff
changeset
|
54 for (i = 0; i < size; i++) |
9f35b262d3f0
Commit some functions that are used by both SIPR and AMR.
vitor
parents:
10011
diff
changeset
|
55 prev = lsf[i] = FFMAX(lsf[i], prev + min_spacing); |
9f35b262d3f0
Commit some functions that are used by both SIPR and AMR.
vitor
parents:
10011
diff
changeset
|
56 } |
9f35b262d3f0
Commit some functions that are used by both SIPR and AMR.
vitor
parents:
10011
diff
changeset
|
57 |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
58 void ff_acelp_lsf2lsp(int16_t *lsp, const int16_t *lsf, int lp_order) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
59 { |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
60 int i; |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
61 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
62 /* Convert LSF to LSP, lsp=cos(lsf) */ |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
63 for(i=0; i<lp_order; i++) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
64 // 20861 = 2.0 / PI in (0.15) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
65 lsp[i] = ff_cos(lsf[i] * 20861 >> 15); // divide by PI and (0,13) -> (0,14) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
66 } |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
67 |
12464
2dd67ed2f947
Move AMRNB lsf2lsp() function to common code for using in future AMRWB decoder.
vitor
parents:
11961
diff
changeset
|
68 void ff_acelp_lsf2lspd(double *lsp, const float *lsf, int lp_order) |
2dd67ed2f947
Move AMRNB lsf2lsp() function to common code for using in future AMRWB decoder.
vitor
parents:
11961
diff
changeset
|
69 { |
2dd67ed2f947
Move AMRNB lsf2lsp() function to common code for using in future AMRWB decoder.
vitor
parents:
11961
diff
changeset
|
70 int i; |
2dd67ed2f947
Move AMRNB lsf2lsp() function to common code for using in future AMRWB decoder.
vitor
parents:
11961
diff
changeset
|
71 |
2dd67ed2f947
Move AMRNB lsf2lsp() function to common code for using in future AMRWB decoder.
vitor
parents:
11961
diff
changeset
|
72 for(i = 0; i < lp_order; i++) |
2dd67ed2f947
Move AMRNB lsf2lsp() function to common code for using in future AMRWB decoder.
vitor
parents:
11961
diff
changeset
|
73 lsp[i] = cos(2.0 * M_PI * lsf[i]); |
2dd67ed2f947
Move AMRNB lsf2lsp() function to common code for using in future AMRWB decoder.
vitor
parents:
11961
diff
changeset
|
74 } |
2dd67ed2f947
Move AMRNB lsf2lsp() function to common code for using in future AMRWB decoder.
vitor
parents:
11961
diff
changeset
|
75 |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
76 /** |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
77 * \brief decodes polynomial coefficients from LSP |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
78 * \param f [out] decoded polynomial coefficients (-0x20000000 <= (3.22) <= 0x1fffffff) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
79 * \param lsp LSP coefficients (-0x8000 <= (0.15) <= 0x7fff) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
80 */ |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
81 static void lsp2poly(int* f, const int16_t* lsp, int lp_half_order) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
82 { |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
83 int i, j; |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
84 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
85 f[0] = 0x400000; // 1.0 in (3.22) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
86 f[1] = -lsp[0] << 8; // *2 and (0.15) -> (3.22) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
87 |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
88 for(i=2; i<=lp_half_order; i++) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
89 { |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
90 f[i] = f[i-2]; |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
91 for(j=i; j>1; j--) |
8201 | 92 f[j] -= MULL(f[j-1], lsp[2*i-2], FRAC_BITS) - f[j-2]; |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
93 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
94 f[1] -= lsp[2*i-2] << 8; |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
95 } |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
96 } |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
97 |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
98 void ff_acelp_lsp2lpc(int16_t* lp, const int16_t* lsp, int lp_half_order) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
99 { |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
100 int i; |
11961 | 101 int f1[MAX_LP_HALF_ORDER+1]; // (3.22) |
102 int f2[MAX_LP_HALF_ORDER+1]; // (3.22) | |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
103 |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
104 lsp2poly(f1, lsp , lp_half_order); |
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
105 lsp2poly(f2, lsp+1, lp_half_order); |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
106 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
107 /* 3.2.6 of G.729, Equations 25 and 26*/ |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
108 lp[0] = 4096; |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
109 for(i=1; i<lp_half_order+1; i++) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
110 { |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
111 int ff1 = f1[i] + f1[i-1]; // (3.22) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
112 int ff2 = f2[i] - f2[i-1]; // (3.22) |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
113 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
114 ff1 += 1 << 10; // for rounding |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
115 lp[i] = (ff1 + ff2) >> 11; // divide by 2 and (3.22) -> (3.12) |
6774 | 116 lp[(lp_half_order << 1) + 1 - i] = (ff1 - ff2) >> 11; // divide by 2 and (3.22) -> (3.12) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
117 } |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
118 } |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
119 |
12465
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
120 void ff_amrwb_lsp2lpc(const double *lsp, float *lp, int lp_order) |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
121 { |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
122 int lp_half_order = lp_order >> 1; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
123 double buf[lp_half_order + 1]; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
124 double pa[lp_half_order + 1]; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
125 double *qa = buf + 1; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
126 int i,j; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
127 |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
128 qa[-1] = 0.0; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
129 |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
130 ff_lsp2polyf(lsp , pa, lp_half_order ); |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
131 ff_lsp2polyf(lsp + 1, qa, lp_half_order - 1); |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
132 |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
133 for (i = 1, j = lp_order - 1; i < lp_half_order; i++, j--) { |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
134 double paf = pa[i] * (1 + lsp[lp_order - 1]); |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
135 double qaf = (qa[i] - qa[i-2]) * (1 - lsp[lp_order - 1]); |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
136 lp[i-1] = (paf + qaf) * 0.5; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
137 lp[j-1] = (paf - qaf) * 0.5; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
138 } |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
139 |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
140 lp[lp_half_order - 1] = (1.0 + lsp[lp_order - 1]) * |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
141 pa[lp_half_order] * 0.5; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
142 |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
143 lp[lp_order - 1] = lsp[lp_order - 1]; |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
144 } |
1921e24d5886
Move lsp2lpc_sipr() function to common code so it can be reused in a
vitor
parents:
12464
diff
changeset
|
145 |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
146 void ff_acelp_lp_decode(int16_t* lp_1st, int16_t* lp_2nd, const int16_t* lsp_2nd, const int16_t* lsp_prev, int lp_order) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
147 { |
11961 | 148 int16_t lsp_1st[MAX_LP_ORDER]; // (0.15) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
149 int i; |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
150 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
151 /* LSP values for first subframe (3.2.5 of G.729, Equation 24)*/ |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
152 for(i=0; i<lp_order; i++) |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
153 #ifdef G729_BITEXACT |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
154 lsp_1st[i] = (lsp_2nd[i] >> 1) + (lsp_prev[i] >> 1); |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
155 #else |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
156 lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) >> 1; |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
157 #endif |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
158 |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
159 ff_acelp_lsp2lpc(lp_1st, lsp_1st, lp_order >> 1); |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
160 |
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
161 /* LSP values for second subframe (3.2.5 of G.729)*/ |
6770
e6338dd4a6e3
Replace hardcoded LP filter order with parameter.
voroshil
parents:
6685
diff
changeset
|
162 ff_acelp_lsp2lpc(lp_2nd, lsp_2nd, lp_order >> 1); |
6685
df4f7cf1ee5f
Fixed-point LSP and LPC decoding routines for ACELP-based codecs
voroshil
parents:
diff
changeset
|
163 } |
10011
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
164 |
10567
d4ca61e293a3
Make lsp2polyf() function non-static for upcoming usage in SIPR
vitor
parents:
10557
diff
changeset
|
165 void ff_lsp2polyf(const double *lsp, double *f, int lp_half_order) |
10011
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
166 { |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
167 int i, j; |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
168 |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
169 f[0] = 1.0; |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
170 f[1] = -2 * lsp[0]; |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
171 lsp -= 2; |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
172 for(i=2; i<=lp_half_order; i++) |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
173 { |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
174 double val = -2 * lsp[2*i]; |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
175 f[i] = val * f[i-1] + 2*f[i-2]; |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
176 for(j=i-1; j>1; j--) |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
177 f[j] += f[j-1] * val + f[j-2]; |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
178 f[1] += val; |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
179 } |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
180 } |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
181 |
10502
f132cde57bbe
Do not hardcode filter order in ff_acelp_lspd2lpc()
vitor
parents:
10463
diff
changeset
|
182 void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order) |
10011
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
183 { |
10506
a1d84a5cf21d
Avoid variable-length array use in ff_acelp_lspd2lpc()
vitor
parents:
10502
diff
changeset
|
184 double pa[MAX_LP_HALF_ORDER+1], qa[MAX_LP_HALF_ORDER+1]; |
10502
f132cde57bbe
Do not hardcode filter order in ff_acelp_lspd2lpc()
vitor
parents:
10463
diff
changeset
|
185 float *lpc2 = lpc + (lp_half_order << 1) - 1; |
10011
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
186 |
10506
a1d84a5cf21d
Avoid variable-length array use in ff_acelp_lspd2lpc()
vitor
parents:
10502
diff
changeset
|
187 assert(lp_half_order <= MAX_LP_HALF_ORDER); |
a1d84a5cf21d
Avoid variable-length array use in ff_acelp_lspd2lpc()
vitor
parents:
10502
diff
changeset
|
188 |
10567
d4ca61e293a3
Make lsp2polyf() function non-static for upcoming usage in SIPR
vitor
parents:
10557
diff
changeset
|
189 ff_lsp2polyf(lsp, pa, lp_half_order); |
d4ca61e293a3
Make lsp2polyf() function non-static for upcoming usage in SIPR
vitor
parents:
10557
diff
changeset
|
190 ff_lsp2polyf(lsp + 1, qa, lp_half_order); |
10011
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
191 |
10502
f132cde57bbe
Do not hardcode filter order in ff_acelp_lspd2lpc()
vitor
parents:
10463
diff
changeset
|
192 while (lp_half_order--) { |
f132cde57bbe
Do not hardcode filter order in ff_acelp_lspd2lpc()
vitor
parents:
10463
diff
changeset
|
193 double paf = pa[lp_half_order+1] + pa[lp_half_order]; |
f132cde57bbe
Do not hardcode filter order in ff_acelp_lspd2lpc()
vitor
parents:
10463
diff
changeset
|
194 double qaf = qa[lp_half_order+1] - qa[lp_half_order]; |
f132cde57bbe
Do not hardcode filter order in ff_acelp_lspd2lpc()
vitor
parents:
10463
diff
changeset
|
195 |
f132cde57bbe
Do not hardcode filter order in ff_acelp_lspd2lpc()
vitor
parents:
10463
diff
changeset
|
196 lpc [ lp_half_order] = 0.5*(paf+qaf); |
f132cde57bbe
Do not hardcode filter order in ff_acelp_lspd2lpc()
vitor
parents:
10463
diff
changeset
|
197 lpc2[-lp_half_order] = 0.5*(paf-qaf); |
10011
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
198 } |
c1cfa4679371
Expose QCELP's floating-point LSP-to-LPC function
superdump
parents:
8201
diff
changeset
|
199 } |
10557
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
200 |
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
201 void ff_sort_nearly_sorted_floats(float *vals, int len) |
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
202 { |
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
203 int i,j; |
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
204 |
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
205 for (i = 0; i < len - 1; i++) |
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
206 for (j = i; j >= 0 && vals[j] > vals[j+1]; j--) |
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
207 FFSWAP(float, vals[j], vals[j+1]); |
f2f4d6fe3f6d
Make sorting function used in TwinVQ a shared function
vitor
parents:
10517
diff
changeset
|
208 } |