Disable unused code for now to allow 'make checkheaders' to pass.
[ffmpeg.git] / libavcodec / qcelpdata.h
1 /*
2  * QCELP decoder
3  * Copyright (c) 2007 Reynaldo H. Verdejo Pinochet
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #ifndef AVCODEC_QCELPDATA_H
23 #define AVCODEC_QCELPDATA_H
24
25 /**
26  * @file qcelpdata.h
27  * Data tables for the QCELP decoder
28  * @author Reynaldo H. Verdejo Pinochet
29  * @remark FFmpeg merging spearheaded by Kenan Gillet
30  */
31
32 #include <stddef.h>
33 #include <stdint.h>
34 #include "libavutil/common.h"
35
36 /**
37  * pre-calculated table for hammsinc function
38  * Only half of the table is needed because of symmetry.
39  *
40  * TIA/EIA/IS-733 2.4.5.2-2/3
41  */
42 static const float qcelp_hammsinc_table[4] = { -0.006822,  0.041249, -0.143459,  0.588863};
43
44 typedef struct {
45     uint8_t index;  /*!< index into the QCELPContext structure */
46     uint8_t bitpos; /*!< position of the lowest bit in the value's byte */
47     uint8_t bitlen; /*!< number of bits to read */
48 } QCELPBitmap;
49
50 #define QCELP_OF(variable, bit, len) {offsetof(QCELPContext, variable), bit, len}
51
52 /* Disable the below code for now to allow 'make checkheaders' to pass. */
53 #if 0
54 /**
55  * bitmap unpacking tables for RATE_FULL
56  *
57  * TIA/EIA/IS-733 Table 2.4.7.1-1
58  */
59 static const QCELPBitmap qcelp_rate_full_bitmap[] = {
60                                 // start on bit
61     QCELP_OF(lspv  [ 2], 0, 3), // 265
62     QCELP_OF(lspv  [ 1], 0, 7), // 262
63     QCELP_OF(lspv  [ 0], 0, 6), // 255
64     QCELP_OF(lspv  [ 4], 0, 6), // 249
65     QCELP_OF(lspv  [ 3], 0, 6), // 243
66     QCELP_OF(lspv  [ 2], 3, 4), // 237
67     QCELP_OF(cbsign[ 0], 0, 1), // 233
68     QCELP_OF(cbgain[ 0], 0, 4), // 232
69     QCELP_OF(pfrac [ 0], 0, 1), // 228
70     QCELP_OF(plag  [ 0], 0, 7), // 227
71     QCELP_OF(pgain [ 0], 0, 3), // 220
72     QCELP_OF(cindex[ 1], 0, 4), // 217
73     QCELP_OF(cbsign[ 1], 0, 1), // 213
74     QCELP_OF(cbgain[ 1], 0, 4), // 212
75     QCELP_OF(cindex[ 0], 0, 7), // 208
76     QCELP_OF(cbgain[ 3], 0, 1), // 201
77     QCELP_OF(cindex[ 2], 0, 7), // 200
78     QCELP_OF(cbsign[ 2], 0, 1), // 193
79     QCELP_OF(cbgain[ 2], 0, 4), // 192
80     QCELP_OF(cindex[ 1], 4, 3), // 188
81     QCELP_OF(plag  [ 1], 0, 3), // 185
82     QCELP_OF(pgain [ 1], 0, 3), // 182
83     QCELP_OF(cindex[ 3], 0, 7), // 179
84     QCELP_OF(cbsign[ 3], 0, 1), // 172
85     QCELP_OF(cbgain[ 3], 1, 2), // 171
86     QCELP_OF(cindex[ 4], 0, 6), // 169
87     QCELP_OF(cbsign[ 4], 0, 1), // 163
88     QCELP_OF(cbgain[ 4], 0, 4), // 162
89     QCELP_OF(pfrac [ 1], 0, 1), // 158
90     QCELP_OF(plag  [ 1], 3, 4), // 157
91     QCELP_OF(cbgain[ 6], 0, 3), // 153
92     QCELP_OF(cindex[ 5], 0, 7), // 150
93     QCELP_OF(cbsign[ 5], 0, 1), // 143
94     QCELP_OF(cbgain[ 5], 0, 4), // 142
95     QCELP_OF(cindex[ 4], 6, 1), // 138
96     QCELP_OF(cindex[ 7], 0, 3), // 137
97     QCELP_OF(cbsign[ 7], 0, 1), // 134
98     QCELP_OF(cbgain[ 7], 0, 3), // 133
99     QCELP_OF(cindex[ 6], 0, 7), // 130
100     QCELP_OF(cbsign[ 6], 0, 1), // 123
101     QCELP_OF(cbgain[ 6], 3, 1), // 122
102     QCELP_OF(cbgain[ 8], 0, 1), // 121
103     QCELP_OF(pfrac [ 2], 0, 1), // 120
104     QCELP_OF(plag  [ 2], 0, 7), // 119
105     QCELP_OF(pgain [ 2], 0, 3), // 112
106     QCELP_OF(cindex[ 7], 3, 4), // 109
107     QCELP_OF(cbsign[ 9], 0, 1), // 105
108     QCELP_OF(cbgain[ 9], 0, 4), // 104
109     QCELP_OF(cindex[ 8], 0, 7), // 100
110     QCELP_OF(cbsign[ 8], 0, 1), //  93
111     QCELP_OF(cbgain[ 8], 1, 3), //  92
112     QCELP_OF(cindex[10], 0, 4), //  89
113     QCELP_OF(cbsign[10], 0, 1), //  85
114     QCELP_OF(cbgain[10], 0, 4), //  84
115     QCELP_OF(cindex[ 9], 0, 7), //  80
116     QCELP_OF(pgain [ 3], 0, 2), //  73
117     QCELP_OF(cindex[11], 0, 7), //  71
118     QCELP_OF(cbsign[11], 0, 1), //  64
119     QCELP_OF(cbgain[11], 0, 3), //  63
120     QCELP_OF(cindex[10], 4, 3), //  60
121     QCELP_OF(cindex[12], 0, 2), //  57
122     QCELP_OF(cbsign[12], 0, 1), //  55
123     QCELP_OF(cbgain[12], 0, 4), //  54
124     QCELP_OF(pfrac [ 3], 0, 1), //  50
125     QCELP_OF(plag  [ 3], 0, 7), //  49
126     QCELP_OF(pgain [ 3], 2, 1), //  42
127     QCELP_OF(cindex[13], 0, 6), //  41
128     QCELP_OF(cbsign[13], 0, 1), //  35
129     QCELP_OF(cbgain[13], 0, 4), //  34
130     QCELP_OF(cindex[12], 2, 5), //  30
131     QCELP_OF(cbgain[15], 0, 3), //  25
132     QCELP_OF(cindex[14], 0, 7), //  22
133     QCELP_OF(cbsign[14], 0, 1), //  15
134     QCELP_OF(cbgain[14], 0, 4), //  14
135     QCELP_OF(cindex[13], 6, 1), //  10
136     QCELP_OF(reserved,   0, 2), //   9
137     QCELP_OF(cindex[15], 0, 7), //   7
138     QCELP_OF(cbsign[15], 0, 1)  //   0
139 };
140
141 /**
142  * bitmap unpacking tables for RATE_HALF
143  *
144  * TIA/EIA/IS-733 Table 2.4.7.2-1
145  */
146 static const QCELPBitmap qcelp_rate_half_bitmap[] = {
147                                // start on bit
148     QCELP_OF(lspv  [2], 0, 3), // 123
149     QCELP_OF(lspv  [1], 0, 7), // 120
150     QCELP_OF(lspv  [0], 0, 6), // 113
151     QCELP_OF(lspv  [4], 0, 6), // 107
152     QCELP_OF(lspv  [3], 0, 6), // 101
153     QCELP_OF(lspv  [2], 3, 4), //  95
154     QCELP_OF(cbsign[0], 0, 1), //  91
155     QCELP_OF(cbgain[0], 0, 4), //  90
156     QCELP_OF(pfrac [0], 0, 1), //  86
157     QCELP_OF(plag  [0], 0, 7), //  85
158     QCELP_OF(pgain [0], 0, 3), //  78
159     QCELP_OF(plag  [1], 0, 6), //  75
160     QCELP_OF(pgain [1], 0, 3), //  69
161     QCELP_OF(cindex[0], 0, 7), //  66
162     QCELP_OF(pgain [2], 0, 2), //  59
163     QCELP_OF(cindex[1], 0, 7), //  57
164     QCELP_OF(cbsign[1], 0, 1), //  50
165     QCELP_OF(cbgain[1], 0, 4), //  49
166     QCELP_OF(pfrac [1], 0, 1), //  45
167     QCELP_OF(plag  [1], 6, 1), //  44
168     QCELP_OF(cindex[2], 0, 2), //  43
169     QCELP_OF(cbsign[2], 0, 1), //  41
170     QCELP_OF(cbgain[2], 0, 4), //  40
171     QCELP_OF(pfrac [2], 0, 1), //  36
172     QCELP_OF(plag  [2], 0, 7), //  35
173     QCELP_OF(pgain [2], 2, 1), //  28
174     QCELP_OF(pfrac [3], 0, 1), //  27
175     QCELP_OF(plag  [3], 0, 7), //  26
176     QCELP_OF(pgain [3], 0, 3), //  19
177     QCELP_OF(cindex[2], 2, 5), //  16
178     QCELP_OF(cindex[3], 0, 7), //  11
179     QCELP_OF(cbsign[3], 0, 1), //   4
180     QCELP_OF(cbgain[3], 0, 4)  //   3
181 };
182
183 /**
184  * bitmap unpacking tables for RATE_QUARTER
185  *
186  * TIA/EIA/IS-733 Table 2.4.7.3-1
187  */
188 static const QCELPBitmap qcelp_rate_quarter_bitmap[] = {
189                                // start on bit
190     QCELP_OF(lspv  [2], 0, 3), // 53
191     QCELP_OF(lspv  [1], 0, 7), // 50
192     QCELP_OF(lspv  [0], 0, 6), // 43
193     QCELP_OF(lspv  [4], 0, 6), // 37
194     QCELP_OF(lspv  [3], 0, 6), // 31
195     QCELP_OF(lspv  [2], 3, 4), // 25
196     QCELP_OF(cbgain[3], 0, 4), // 21
197     QCELP_OF(cbgain[2], 0, 4), // 17
198     QCELP_OF(cbgain[1], 0, 4), // 13
199     QCELP_OF(cbgain[0], 0, 4), //  9
200     QCELP_OF(reserved,  0, 2), //  5
201     QCELP_OF(cbgain[4], 0, 4)  //  3
202 };
203
204 /**
205  * bitmap unpacking tables for RATE_OCTAVE
206  *
207  * trick: CBSEED is written into QCELPContext.cbsign[15],
208  * which is not used for RATE_OCTAVE.
209  * CBSEED is only used to ensure the occurrence of random bit
210  * patterns in the 16 first bits that are used as the seed.
211  *
212  * TIA/EIA/IS-733 Table 2.4.7.4-1
213  */
214 static const QCELPBitmap qcelp_rate_octave_bitmap[] = {
215                                 // start on bit
216     QCELP_OF(cbsign[15], 3, 1), // 19
217     QCELP_OF(lspv   [0], 0, 1), // 18
218     QCELP_OF(lspv   [1], 0, 1), // 17
219     QCELP_OF(lspv   [2], 0, 1), // 16
220     QCELP_OF(cbsign[15], 2, 1), // 15
221     QCELP_OF(lspv   [3], 0, 1), // 14
222     QCELP_OF(lspv   [4], 0, 1), // 13
223     QCELP_OF(lspv   [5], 0, 1), // 12
224     QCELP_OF(cbsign[15], 1, 1), // 11
225     QCELP_OF(lspv   [6], 0, 1), // 10
226     QCELP_OF(lspv   [7], 0, 1), //  9
227     QCELP_OF(lspv   [8], 0, 1), //  8
228     QCELP_OF(cbsign[15], 0, 1), //  7
229     QCELP_OF(lspv   [9], 0, 1), //  6
230     QCELP_OF(cbgain [0], 0, 2), //  7
231     QCELP_OF(reserved,   0, 4)  //  3
232 };
233
234 /**
235  * position of the bitmapping data for each packet type in
236  * the QCELPContext
237  */
238 static const QCELPBitmap * const qcelp_unpacking_bitmaps_per_rate[5] = {
239     NULL,                     ///!< for SILENCE rate
240     qcelp_rate_octave_bitmap,
241     qcelp_rate_quarter_bitmap,
242     qcelp_rate_half_bitmap,
243     qcelp_rate_full_bitmap,
244 };
245
246 static const uint16_t qcelp_bits_per_rate[5] = {
247     0, ///!< for SILENCE rate
248     FF_ARRAY_ELEMS(qcelp_rate_octave_bitmap),
249     FF_ARRAY_ELEMS(qcelp_rate_quarter_bitmap),
250     FF_ARRAY_ELEMS(qcelp_rate_half_bitmap),
251     FF_ARRAY_ELEMS(qcelp_rate_full_bitmap),
252 };
253 #endif
254
255 typedef uint16_t qcelp_vector[2];
256
257 /**
258  * LSP vector quantization tables in x*10000 form
259  *
260  * TIA/EIA/IS-733 tables 2.4.3.2.6.3-1 through 2.4.3.2.6.3-5
261  */
262
263 static const qcelp_vector qcelp_lspvq1[64]= {
264 { 327, 118},{ 919, 111},{ 427, 440},{1327, 185},
265 { 469,  50},{1272,  91},{ 892,  59},{1771, 193},
266 { 222, 158},{1100, 127},{ 827,  55},{ 978, 791},
267 { 665,  47},{ 700,1401},{ 670, 859},{1913,1048},
268 { 471, 215},{1046, 125},{ 645, 298},{1599, 160},
269 { 593,  39},{1187, 462},{ 749, 341},{1520, 511},
270 { 290, 792},{ 909, 362},{ 753,  81},{1111,1058},
271 { 519, 253},{ 828, 839},{ 685, 541},{1421,1258},
272 { 386, 130},{ 962, 119},{ 542, 387},{1431, 185},
273 { 526,  51},{1175, 260},{ 831, 167},{1728, 510},
274 { 273, 437},{1172, 113},{ 771, 144},{1122, 751},
275 { 619, 119},{ 492,1276},{ 658, 695},{1882, 615},
276 { 415, 200},{1018,  88},{ 681, 339},{1436, 325},
277 { 555, 122},{1042, 485},{ 826, 345},{1374, 743},
278 { 383,1018},{1005, 358},{ 704,  86},{1301, 586},
279 { 597, 241},{ 832, 621},{ 555, 573},{1504, 839}};
280
281 static const qcelp_vector qcelp_lspvq2[128]= {
282 { 255, 293},{ 904, 219},{ 151,1211},{1447, 498},
283 { 470, 253},{1559, 177},{1547, 994},{2394, 242},
284 {  91, 813},{ 857, 590},{ 934,1326},{1889, 282},
285 { 813, 472},{1057,1494},{ 450,3315},{2163,1895},
286 { 538, 532},{1399, 218},{ 146,1552},{1755, 626},
287 { 822, 202},{1299, 663},{ 706,1732},{2656, 401},
288 { 418, 745},{ 762,1038},{ 583,1748},{1746,1285},
289 { 527,1169},{1314, 830},{ 556,2116},{1073,2321},
290 { 297, 570},{ 981, 403},{ 468,1103},{1740, 243},
291 { 725, 179},{1255, 474},{1374,1362},{1922, 912},
292 { 285, 947},{ 930, 700},{ 593,1372},{1909, 576},
293 { 588, 916},{1110,1116},{ 224,2719},{1633,2220},
294 { 402, 520},{1061, 448},{ 402,1352},{1499, 775},
295 { 664, 589},{1081, 727},{ 801,2206},{2165,1157},
296 { 566, 802},{ 911,1116},{ 306,1703},{1792, 836},
297 { 655, 999},{1061,1038},{ 298,2089},{1110,1753},
298 { 361, 311},{ 970, 239},{ 265,1231},{1495, 573},
299 { 566, 262},{1569, 293},{1341,1144},{2271, 544},
300 { 214, 877},{ 847, 719},{ 794,1384},{2067, 274},
301 { 703, 688},{1099,1306},{ 391,2947},{2024,1670},
302 { 471, 525},{1245, 290},{ 264,1557},{1568, 807},
303 { 718, 399},{1193, 685},{ 883,1594},{2729, 764},
304 { 500, 754},{ 809,1108},{ 541,1648},{1523,1385},
305 { 614,1196},{1209, 847},{ 345,2242},{1442,1747},
306 { 199, 560},{1092, 194},{ 349,1253},{1653, 507},
307 { 625, 354},{1376, 431},{1187,1465},{2164, 872},
308 { 360, 974},{1008, 698},{ 704,1346},{2114, 452},
309 { 720, 816},{1240,1089},{ 439,2475},{1498,2040},
310 { 336, 718},{1213, 187},{ 451,1450},{1368, 885},
311 { 592, 578},{1131, 531},{ 861,1855},{1764,1500},
312 { 444, 970},{ 935, 903},{ 424,1687},{1633,1102},
313 { 793, 897},{1060, 897},{ 185,2011},{1205,1855}};
314
315 static const qcelp_vector qcelp_lspvq3[128]= {
316 { 225, 283},{1296, 355},{ 543, 343},{2073, 274},
317 { 204,1099},{1562, 523},{1388, 161},{2784, 274},
318 { 112, 849},{1870, 175},{1189, 160},{1490,1088},
319 { 969,1115},{ 659,3322},{1158,1073},{3183,1363},
320 { 517, 223},{1740, 223},{ 704, 387},{2637, 234},
321 { 692,1005},{1287,1610},{ 952, 532},{2393, 646},
322 { 490, 552},{1619, 657},{ 845, 670},{1784,2280},
323 { 191,1775},{ 272,2868},{ 942, 952},{2628,1479},
324 { 278, 579},{1565, 218},{ 814, 180},{2379, 187},
325 { 276,1444},{1199,1223},{1200, 349},{3009, 307},
326 { 312, 844},{1898, 306},{ 863, 470},{1685,1241},
327 { 513,1727},{ 711,2233},{1085, 864},{3398, 527},
328 { 414, 440},{1356, 612},{ 964, 147},{2173, 738},
329 { 465,1292},{ 877,1749},{1104, 689},{2105,1311},
330 { 580, 864},{1895, 752},{ 652, 609},{1485,1699},
331 { 514,1400},{ 386,2131},{ 933, 798},{2473, 986},
332 { 334, 360},{1375, 398},{ 621, 276},{2183, 280},
333 { 311,1114},{1382, 807},{1284, 175},{2605, 636},
334 { 230, 816},{1739, 408},{1074, 176},{1619,1120},
335 { 784,1371},{ 448,3050},{1189, 880},{3039,1165},
336 { 424, 241},{1672, 186},{ 815, 333},{2432, 324},
337 { 584,1029},{1137,1546},{1015, 585},{2198, 995},
338 { 574, 581},{1746, 647},{ 733, 740},{1938,1737},
339 { 347,1710},{ 373,2429},{ 787,1061},{2439,1438},
340 { 185, 536},{1489, 178},{ 703, 216},{2178, 487},
341 { 154,1421},{1414, 994},{1103, 352},{3072, 473},
342 { 408, 819},{2055, 168},{ 998, 354},{1917,1140},
343 { 665,1799},{ 993,2213},{1234, 631},{3003, 762},
344 { 373, 620},{1518, 425},{ 913, 300},{1966, 836},
345 { 402,1185},{ 948,1385},{1121, 555},{1802,1509},
346 { 474, 886},{1888, 610},{ 739, 585},{1231,2379},
347 { 661,1335},{ 205,2211},{ 823, 822},{2480,1179}};
348
349 static const qcelp_vector qcelp_lspvq4[64]= {
350 { 348, 311},{ 812,1145},{ 552, 461},{1826, 263},
351 { 601, 675},{1730, 172},{1523, 193},{2449, 277},
352 { 334, 668},{ 805,1441},{1319, 207},{1684, 910},
353 { 582,1318},{1403,1098},{ 979, 832},{2700,1359},
354 { 624, 228},{1292, 979},{ 800, 195},{2226, 285},
355 { 730, 862},{1537, 601},{1115, 509},{2720, 354},
356 { 218,1167},{1212,1538},{1074, 247},{1674,1710},
357 { 322,2142},{1263, 777},{ 981, 556},{2119,1710},
358 { 193, 596},{1035, 957},{ 694, 397},{1997, 253},
359 { 743, 603},{1584, 321},{1346, 346},{2221, 708},
360 { 451, 732},{1040,1415},{1184, 230},{1853, 919},
361 { 310,1661},{1625, 706},{ 856, 843},{2902, 702},
362 { 467, 348},{1108,1048},{ 859, 306},{1964, 463},
363 { 560,1013},{1425, 533},{1142, 634},{2391, 879},
364 { 397,1084},{1345,1700},{ 976, 248},{1887,1189},
365 { 644,2087},{1262, 603},{ 877, 550},{2203,1307}};
366
367 static const qcelp_vector qcelp_lspvq5[64]= {
368 { 360, 222},{ 820,1097},{ 601, 319},{1656, 198},
369 { 604, 513},{1552, 141},{1391, 155},{2474, 261},
370 { 269, 785},{1463, 646},{1123, 191},{2015, 223},
371 { 785, 844},{1202,1011},{ 980, 807},{3014, 793},
372 { 570, 180},{1135,1382},{ 778, 256},{1901, 179},
373 { 807, 622},{1461, 458},{1231, 178},{2028, 821},
374 { 387, 927},{1496,1004},{ 888, 392},{2246, 341},
375 { 295,1462},{1156, 694},{1022, 473},{2226,1364},
376 { 210, 478},{1029,1020},{ 722, 181},{1730, 251},
377 { 730, 488},{1465, 293},{1303, 326},{2595, 387},
378 { 458, 584},{1569, 742},{1029, 173},{1910, 495},
379 { 605,1159},{1268, 719},{ 973, 646},{2872, 428},
380 { 443, 334},{ 835,1465},{ 912, 138},{1716, 442},
381 { 620, 778},{1316, 450},{1186, 335},{1446,1665},
382 { 486,1050},{1675,1019},{ 880, 278},{2214, 202},
383 { 539,1564},{1142, 533},{ 984, 391},{2130,1089}};
384
385 static const qcelp_vector * const qcelp_lspvq[5] = {
386     qcelp_lspvq1,
387     qcelp_lspvq2,
388     qcelp_lspvq3,
389     qcelp_lspvq4,
390     qcelp_lspvq5
391 };
392
393 /**
394  * the final gain scalefactor before clipping into a usable output float
395  */
396 #define QCELP_SCALE 8192.
397
398 /**
399  * the upper boundary of the clipping, depends on QCELP_SCALE
400  */
401 #define QCELP_CLIP_UPPER_BOUND (8191.75/8192.)
402
403 /**
404  * the lower boundary of the clipping, depends on QCELP_SCALE
405  */
406 #define QCELP_CLIP_LOWER_BOUND -1.
407
408 /**
409  * table for computing Ga (decoded linear codebook gain magnitude)
410  *
411  * @note The table could fit in int16_t in x*8 form, but it seems
412  *       to be slower on x86
413  *
414  * TIA/EIA/IS-733 2.4.6.2.1-3
415  */
416
417 static const float qcelp_g12ga[61] = {
418     1.000/QCELP_SCALE,   1.125/QCELP_SCALE,   1.250/QCELP_SCALE,   1.375/QCELP_SCALE,
419     1.625/QCELP_SCALE,   1.750/QCELP_SCALE,   2.000/QCELP_SCALE,   2.250/QCELP_SCALE,
420     2.500/QCELP_SCALE,   2.875/QCELP_SCALE,   3.125/QCELP_SCALE,   3.500/QCELP_SCALE,
421     4.000/QCELP_SCALE,   4.500/QCELP_SCALE,   5.000/QCELP_SCALE,   5.625/QCELP_SCALE,
422     6.250/QCELP_SCALE,   7.125/QCELP_SCALE,   8.000/QCELP_SCALE,   8.875/QCELP_SCALE,
423    10.000/QCELP_SCALE,  11.250/QCELP_SCALE,  12.625/QCELP_SCALE,  14.125/QCELP_SCALE,
424    15.875/QCELP_SCALE,  17.750/QCELP_SCALE,  20.000/QCELP_SCALE,  22.375/QCELP_SCALE,
425    25.125/QCELP_SCALE,  28.125/QCELP_SCALE,  31.625/QCELP_SCALE,  35.500/QCELP_SCALE,
426    39.750/QCELP_SCALE,  44.625/QCELP_SCALE,  50.125/QCELP_SCALE,  56.250/QCELP_SCALE,
427    63.125/QCELP_SCALE,  70.750/QCELP_SCALE,  79.375/QCELP_SCALE,  89.125/QCELP_SCALE,
428   100.000/QCELP_SCALE, 112.250/QCELP_SCALE, 125.875/QCELP_SCALE, 141.250/QCELP_SCALE,
429   158.500/QCELP_SCALE, 177.875/QCELP_SCALE, 199.500/QCELP_SCALE, 223.875/QCELP_SCALE,
430   251.250/QCELP_SCALE, 281.875/QCELP_SCALE, 316.250/QCELP_SCALE, 354.875/QCELP_SCALE,
431   398.125/QCELP_SCALE, 446.625/QCELP_SCALE, 501.125/QCELP_SCALE, 562.375/QCELP_SCALE,
432   631.000/QCELP_SCALE, 708.000/QCELP_SCALE, 794.375/QCELP_SCALE, 891.250/QCELP_SCALE,
433  1000.000/QCELP_SCALE};
434
435 /**
436  * circular codebook for rate 1 frames in x*100 form
437  *
438  * TIA/EIA/IS-733 2.4.6.1-2
439  */
440 static const int16_t qcelp_rate_full_codebook[128] = {
441      10,  -65,  -59,   12,  110,   34, -134,  157,
442     104,  -84,  -34, -115,   23, -101,    3,   45,
443    -101,  -16,  -59,   28,  -45,  134,  -67,   22,
444      61,  -29,  226,  -26,  -55, -179,  157,  -51,
445    -220,  -93,  -37,   60,  118,   74,  -48,  -95,
446    -181,  111,   36,  -52, -215,   78, -112,   39,
447     -17,  -47, -223,   19,   12,  -98, -142,  130,
448      54, -127,   21,  -12,   39,  -48,   12,  128,
449       6, -167,   82, -102,  -79,   55,  -44,   48,
450     -20,  -53,    8,  -61,   11,  -70, -157, -168,
451      20,  -56,  -74,   78,   33,  -63, -173,   -2,
452     -75,  -53, -146,   77,   66,  -29,    9,  -75,
453      65,  119,  -43,   76,  233,   98,  125, -156,
454     -27,   78,   -9,  170,  176,  143, -148,   -7,
455      27, -136,    5,   27,   18,  139,  204,    7,
456    -184, -197,   52,   -3,   78, -189,    8,  -65
457 };
458 #define QCELP_RATE_FULL_CODEBOOK_RATIO .01
459
460 /**
461  * circular codebook for rate 1/2 frames in x*2 form
462  *
463  * TIA/EIA/IS-733 2.4.6.1-1
464  */
465 static const int8_t qcelp_rate_half_codebook[128] = {
466      0, -4,  0, -3,  0,  0,  0,  0,
467      0,  0,  0,  0,  0,  0,  0,  0,
468      0, -3, -2,  0,  0,  0,  0,  0,
469      0,  0,  0,  0,  0,  0,  0,  5,
470      0,  0,  0,  0,  0,  0,  4,  0,
471      0,  3,  2,  0,  3,  4,  0,  0,
472      0,  0,  0,  0,  0,  0,  0,  0,
473      0,  0,  0,  0,  0,  3,  0,  0,
474     -3,  3,  0,  0, -2,  0,  3,  0,
475      0,  0,  0,  0,  0,  0, -5,  0,
476      0,  0,  0,  3,  0,  0,  0,  3,
477      0,  0,  0,  0,  0,  0,  0,  4,
478      0,  0,  0,  0,  0,  0,  0,  0,
479      0,  3,  6, -3, -4,  0, -3, -3,
480      3, -3,  0,  0,  0,  0,  0,  0,
481      0,  0,  0,  0,  0,  0,  0,  0
482 };
483 #define QCELP_RATE_HALF_CODEBOOK_RATIO 0.5
484
485 /**
486  * sqrt(1.887) is the maximum of the pseudorandom
487  * white sequence used to generate the scaled codebook
488  * vector for bitrate 1/4.
489  *
490  * TIA/EIA/IS-733 2.4.8.1.2
491  */
492 #define QCELP_SQRT1887 1.373681186
493
494 /**
495  * table for impulse response of BPF used to filter
496  * the white excitation for bitrate 1/4 synthesis
497  *
498  * Only half the tables are needed because of symmetry.
499  *
500  * TIA/EIA/IS-733 2.4.8.1.2-1.1
501  */
502 static const double qcelp_rnd_fir_coefs[11] = {
503   -1.344519e-1, 1.735384e-2, -6.905826e-2, 2.434368e-2,
504   -8.210701e-2, 3.041388e-2, -9.251384e-2, 3.501983e-2,
505   -9.918777e-2, 3.749518e-2,  8.985137e-1
506 };
507
508 /**
509  * This spread factor is used, for bitrate 1/8 and I_F_Q,
510  * to force the LSP frequencies to be at least 80 Hz apart.
511  *
512  * TIA/EIA/IS-733 2.4.3.3.2
513  */
514 #define QCELP_LSP_SPREAD_FACTOR 0.02
515
516 /**
517  * predictor coefficient for the conversion of LSP codes
518  * to LSP frequencies for 1/8 and I_F_Q
519  *
520  * TIA/EIA/IS-733 2.4.3.2.7-2
521  */
522 #define QCELP_LSP_OCTAVE_PREDICTOR 29.0/32
523
524 #endif /* AVCODEC_QCELPDATA_H */