Statistics
| Branch: | Revision:

ffmpeg / libavcodec / qcelpdata.h @ f29289ee

History | View | Annotate | Download (18.2 KB)

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
 */
30

    
31
#include <stdint.h>
32

    
33
/**
34
 * pre-calculated table for hammsinc function
35
 * Only half of the table is needed because of symmetry.
36
 *
37
 * TIA/EIA/IS-733 2.4.5.2-2/3
38
 */
39
static const float qcelp_hammsinc_table[4] = { -0.006822,  0.041249, -0.143459,  0.588863};
40

    
41
typedef struct {
42
    uint8_t index;  /*!< index into the QCELPContext structure */
43
    uint8_t bitpos; /*!< position of the lowest bit in the value's byte */
44
    uint8_t bitlen; /*!< number of bits to read */
45
} QCELPBitmap;
46

    
47
#define QCELP_OF(variable, bit, len) {offsetof(QCELPContext, variable), bit, len}
48

    
49
/**
50
 * bitmap unpacking tables for RATE_FULL
51
 *
52
 * TIA/EIA/IS-733 Table 2.4.7.1-1
53
 */
54
static const QCELPBitmap qcelp_rate_full_bitmap[] = {
55
                                // start on bit
56
    QCELP_OF(lspv  [ 2], 0, 3), // 265
57
    QCELP_OF(lspv  [ 1], 0, 7), // 262
58
    QCELP_OF(lspv  [ 0], 0, 6), // 255
59
    QCELP_OF(lspv  [ 4], 0, 6), // 249
60
    QCELP_OF(lspv  [ 3], 0, 6), // 243
61
    QCELP_OF(lspv  [ 2], 3, 4), // 237
62
    QCELP_OF(cbsign[ 0], 0, 1), // 233
63
    QCELP_OF(cbgain[ 0], 0, 4), // 232
64
    QCELP_OF(pfrac [ 0], 0, 1), // 228
65
    QCELP_OF(plag  [ 0], 0, 7), // 227
66
    QCELP_OF(pgain [ 0], 0, 3), // 220
67
    QCELP_OF(cindex[ 1], 0, 4), // 217
68
    QCELP_OF(cbsign[ 1], 0, 1), // 213
69
    QCELP_OF(cbgain[ 1], 0, 4), // 212
70
    QCELP_OF(cindex[ 0], 0, 7), // 208
71
    QCELP_OF(cbgain[ 3], 0, 1), // 201
72
    QCELP_OF(cindex[ 2], 0, 7), // 200
73
    QCELP_OF(cbsign[ 2], 0, 1), // 193
74
    QCELP_OF(cbgain[ 2], 0, 4), // 192
75
    QCELP_OF(cindex[ 1], 4, 3), // 188
76
    QCELP_OF(plag  [ 1], 0, 3), // 185
77
    QCELP_OF(pgain [ 1], 0, 3), // 182
78
    QCELP_OF(cindex[ 3], 0, 7), // 179
79
    QCELP_OF(cbsign[ 3], 0, 1), // 172
80
    QCELP_OF(cbgain[ 3], 1, 2), // 171
81
    QCELP_OF(cindex[ 4], 0, 6), // 169
82
    QCELP_OF(cbsign[ 4], 0, 1), // 163
83
    QCELP_OF(cbgain[ 4], 0, 4), // 162
84
    QCELP_OF(pfrac [ 1], 0, 1), // 158
85
    QCELP_OF(plag  [ 1], 3, 4), // 157
86
    QCELP_OF(cbgain[ 6], 0, 3), // 153
87
    QCELP_OF(cindex[ 5], 0, 7), // 150
88
    QCELP_OF(cbsign[ 5], 0, 1), // 143
89
    QCELP_OF(cbgain[ 5], 0, 4), // 142
90
    QCELP_OF(cindex[ 4], 6, 1), // 138
91
    QCELP_OF(cindex[ 7], 0, 3), // 137
92
    QCELP_OF(cbsign[ 7], 0, 1), // 134
93
    QCELP_OF(cbgain[ 7], 0, 3), // 133
94
    QCELP_OF(cindex[ 6], 0, 7), // 130
95
    QCELP_OF(cbsign[ 6], 0, 1), // 123
96
    QCELP_OF(cbgain[ 6], 3, 1), // 122
97
    QCELP_OF(cbgain[ 8], 0, 1), // 121
98
    QCELP_OF(pfrac [ 2], 0, 1), // 120
99
    QCELP_OF(plag  [ 2], 0, 7), // 119
100
    QCELP_OF(pgain [ 2], 0, 3), // 112
101
    QCELP_OF(cindex[ 7], 3, 4), // 109
102
    QCELP_OF(cbsign[ 9], 0, 1), // 105
103
    QCELP_OF(cbgain[ 9], 0, 4), // 104
104
    QCELP_OF(cindex[ 8], 0, 7), // 100
105
    QCELP_OF(cbsign[ 8], 0, 1), //  93
106
    QCELP_OF(cbgain[ 8], 1, 3), //  92
107
    QCELP_OF(cindex[10], 0, 4), //  89
108
    QCELP_OF(cbsign[10], 0, 1), //  85
109
    QCELP_OF(cbgain[10], 0, 4), //  84
110
    QCELP_OF(cindex[ 9], 0, 7), //  80
111
    QCELP_OF(pgain [ 3], 0, 2), //  73
112
    QCELP_OF(cindex[11], 0, 7), //  71
113
    QCELP_OF(cbsign[11], 0, 1), //  64
114
    QCELP_OF(cbgain[11], 0, 3), //  63
115
    QCELP_OF(cindex[10], 4, 3), //  60
116
    QCELP_OF(cindex[12], 0, 2), //  57
117
    QCELP_OF(cbsign[12], 0, 1), //  55
118
    QCELP_OF(cbgain[12], 0, 4), //  54
119
    QCELP_OF(pfrac [ 3], 0, 1), //  50
120
    QCELP_OF(plag  [ 3], 0, 7), //  49
121
    QCELP_OF(pgain [ 3], 2, 1), //  42
122
    QCELP_OF(cindex[13], 0, 6), //  41
123
    QCELP_OF(cbsign[13], 0, 1), //  35
124
    QCELP_OF(cbgain[13], 0, 4), //  34
125
    QCELP_OF(cindex[12], 2, 5), //  30
126
    QCELP_OF(cbgain[15], 0, 3), //  25
127
    QCELP_OF(cindex[14], 0, 7), //  22
128
    QCELP_OF(cbsign[14], 0, 1), //  15
129
    QCELP_OF(cbgain[14], 0, 4), //  14
130
    QCELP_OF(cindex[13], 6, 1), //  10
131
    QCELP_OF(reserved,   0, 2), //   9
132
    QCELP_OF(cindex[15], 0, 7), //   7
133
    QCELP_OF(cbsign[15], 0, 1)  //   0
134
};
135

    
136
/**
137
 * bitmap unpacking tables for RATE_HALF
138
 *
139
 * TIA/EIA/IS-733 Table 2.4.7.2-1
140
 */
141
static const QCELPBitmap qcelp_rate_half_bitmap[] = {
142
                               // start on bit
143
    QCELP_OF(lspv  [2], 0, 3), // 123
144
    QCELP_OF(lspv  [1], 0, 7), // 120
145
    QCELP_OF(lspv  [0], 0, 6), // 113
146
    QCELP_OF(lspv  [4], 0, 6), // 107
147
    QCELP_OF(lspv  [3], 0, 6), // 101
148
    QCELP_OF(lspv  [2], 3, 4), //  95
149
    QCELP_OF(cbsign[0], 0, 1), //  91
150
    QCELP_OF(cbgain[0], 0, 4), //  90
151
    QCELP_OF(pfrac [0], 0, 1), //  86
152
    QCELP_OF(plag  [0], 0, 7), //  85
153
    QCELP_OF(pgain [0], 0, 3), //  78
154
    QCELP_OF(plag  [1], 0, 6), //  75
155
    QCELP_OF(pgain [1], 0, 3), //  69
156
    QCELP_OF(cindex[0], 0, 7), //  66
157
    QCELP_OF(pgain [2], 0, 2), //  59
158
    QCELP_OF(cindex[1], 0, 7), //  57
159
    QCELP_OF(cbsign[1], 0, 1), //  50
160
    QCELP_OF(cbgain[1], 0, 4), //  49
161
    QCELP_OF(pfrac [1], 0, 1), //  45
162
    QCELP_OF(plag  [1], 6, 1), //  44
163
    QCELP_OF(cindex[2], 0, 2), //  43
164
    QCELP_OF(cbsign[2], 0, 1), //  41
165
    QCELP_OF(cbgain[2], 0, 4), //  40
166
    QCELP_OF(pfrac [2], 0, 1), //  36
167
    QCELP_OF(plag  [2], 0, 7), //  35
168
    QCELP_OF(pgain [2], 2, 1), //  28
169
    QCELP_OF(pfrac [3], 0, 1), //  27
170
    QCELP_OF(plag  [3], 0, 7), //  26
171
    QCELP_OF(pgain [3], 0, 3), //  19
172
    QCELP_OF(cindex[2], 2, 5), //  16
173
    QCELP_OF(cindex[3], 0, 7), //  11
174
    QCELP_OF(cbsign[3], 0, 1), //   4
175
    QCELP_OF(cbgain[3], 0, 4)  //   3
176
};
177

    
178
/**
179
 * bitmap unpacking tables for RATE_QUARTER
180
 *
181
 * TIA/EIA/IS-733 Table 2.4.7.3-1
182
 */
183
static const QCELPBitmap qcelp_rate_quarter_bitmap[] = {
184
                               // start on bit
185
    QCELP_OF(lspv  [2], 0, 3), // 53
186
    QCELP_OF(lspv  [1], 0, 7), // 50
187
    QCELP_OF(lspv  [0], 0, 6), // 43
188
    QCELP_OF(lspv  [4], 0, 6), // 37
189
    QCELP_OF(lspv  [3], 0, 6), // 31
190
    QCELP_OF(lspv  [2], 3, 4), // 25
191
    QCELP_OF(cbgain[3], 0, 4), // 21
192
    QCELP_OF(cbgain[2], 0, 4), // 17
193
    QCELP_OF(cbgain[1], 0, 4), // 13
194
    QCELP_OF(cbgain[0], 0, 4), //  9
195
    QCELP_OF(reserved,  0, 2), //  5
196
    QCELP_OF(cbgain[4], 0, 4)  //  3
197
};
198

    
199
/**
200
 * bitmap unpacking tables for RATE_OCTAVE
201
 *
202
 * trick: CBSEED is written into QCELPContext.cbsign[15],
203
 * which is not used for RATE_OCTAVE.
204
 * CBSEED is only used to ensure the occurrence of random bit
205
 * patterns in the 16 first bits that are used as the seed.
206
 *
207
 * TIA/EIA/IS-733 Table 2.4.7.4-1
208
 */
209
static const QCELPBitmap qcelp_rate_octave_bitmap[] = {
210
                                // start on bit
211
    QCELP_OF(cbsign[15], 3, 1), // 19
212
    QCELP_OF(lspv   [0], 0, 1), // 18
213
    QCELP_OF(lspv   [1], 0, 1), // 17
214
    QCELP_OF(lspv   [2], 0, 1), // 16
215
    QCELP_OF(cbsign[15], 2, 1), // 15
216
    QCELP_OF(lspv   [3], 0, 1), // 14
217
    QCELP_OF(lspv   [4], 0, 1), // 13
218
    QCELP_OF(lspv   [5], 0, 1), // 12
219
    QCELP_OF(cbsign[15], 1, 1), // 11
220
    QCELP_OF(lspv   [6], 0, 1), // 10
221
    QCELP_OF(lspv   [7], 0, 1), //  9
222
    QCELP_OF(lspv   [8], 0, 1), //  8
223
    QCELP_OF(cbsign[15], 0, 1), //  7
224
    QCELP_OF(lspv   [9], 0, 1), //  6
225
    QCELP_OF(cbgain [0], 0, 2), //  7
226
    QCELP_OF(reserved,   0, 4)  //  3
227
};
228

    
229
/**
230
 * position of the bitmapping data for each packet type in
231
 * the QCELPContext
232
 */
233
static const QCELPBitmap * const qcelp_unpacking_bitmaps_per_rate[5] = {
234
    NULL,                     ///!< for SILENCE rate
235
    qcelp_rate_octave_bitmap,
236
    qcelp_rate_quarter_bitmap,
237
    qcelp_rate_half_bitmap,
238
    qcelp_rate_full_bitmap,
239
};
240

    
241
static const uint16_t qcelp_bits_per_rate[5] = {
242
    0, ///!< for SILENCE rate
243
    FF_ARRAY_ELEMS(qcelp_rate_octave_bitmap),
244
    FF_ARRAY_ELEMS(qcelp_rate_quarter_bitmap),
245
    FF_ARRAY_ELEMS(qcelp_rate_half_bitmap),
246
    FF_ARRAY_ELEMS(qcelp_rate_full_bitmap),
247
};
248

    
249
typedef uint16_t qcelp_vector[2];
250

    
251
/**
252
 * LSP vector quantization tables in x*10000 form
253
 *
254
 * TIA/EIA/IS-733 tables 2.4.3.2.6.3-1 through 2.4.3.2.6.3-5
255
 */
256

    
257
static const qcelp_vector qcelp_lspvq1[64]= {
258
{ 327, 118},{ 919, 111},{ 427, 440},{1327, 185},
259
{ 469,  50},{1272,  91},{ 892,  59},{1771, 193},
260
{ 222, 158},{1100, 127},{ 827,  55},{ 978, 791},
261
{ 665,  47},{ 700,1401},{ 670, 859},{1913,1048},
262
{ 471, 215},{1046, 125},{ 645, 298},{1599, 160},
263
{ 593,  39},{1187, 462},{ 749, 341},{1520, 511},
264
{ 290, 792},{ 909, 362},{ 753,  81},{1111,1058},
265
{ 519, 253},{ 828, 839},{ 685, 541},{1421,1258},
266
{ 386, 130},{ 962, 119},{ 542, 387},{1431, 185},
267
{ 526,  51},{1175, 260},{ 831, 167},{1728, 510},
268
{ 273, 437},{1172, 113},{ 771, 144},{1122, 751},
269
{ 619, 119},{ 492,1276},{ 658, 695},{1882, 615},
270
{ 415, 200},{1018,  88},{ 681, 339},{1436, 325},
271
{ 555, 122},{1042, 485},{ 826, 345},{1374, 743},
272
{ 383,1018},{1005, 358},{ 704,  86},{1301, 586},
273
{ 597, 241},{ 832, 621},{ 555, 573},{1504, 839}};
274

    
275
static const qcelp_vector qcelp_lspvq2[128]= {
276
{ 255, 293},{ 904, 219},{ 151,1211},{1447, 498},
277
{ 470, 253},{1559, 177},{1547, 994},{2394, 242},
278
{  91, 813},{ 857, 590},{ 934,1326},{1889, 282},
279
{ 813, 472},{1057,1494},{ 450,3315},{2163,1895},
280
{ 538, 532},{1399, 218},{ 146,1552},{1755, 626},
281
{ 822, 202},{1299, 663},{ 706,1732},{2656, 401},
282
{ 418, 745},{ 762,1038},{ 583,1748},{1746,1285},
283
{ 527,1169},{1314, 830},{ 556,2116},{1073,2321},
284
{ 297, 570},{ 981, 403},{ 468,1103},{1740, 243},
285
{ 725, 179},{1255, 474},{1374,1362},{1922, 912},
286
{ 285, 947},{ 930, 700},{ 593,1372},{1909, 576},
287
{ 588, 916},{1110,1116},{ 224,2719},{1633,2220},
288
{ 402, 520},{1061, 448},{ 402,1352},{1499, 775},
289
{ 664, 589},{1081, 727},{ 801,2206},{2165,1157},
290
{ 566, 802},{ 911,1116},{ 306,1703},{1792, 836},
291
{ 655, 999},{1061,1038},{ 298,2089},{1110,1753},
292
{ 361, 311},{ 970, 239},{ 265,1231},{1495, 573},
293
{ 566, 262},{1569, 293},{1341,1144},{2271, 544},
294
{ 214, 877},{ 847, 719},{ 794,1384},{2067, 274},
295
{ 703, 688},{1099,1306},{ 391,2947},{2024,1670},
296
{ 471, 525},{1245, 290},{ 264,1557},{1568, 807},
297
{ 718, 399},{1193, 685},{ 883,1594},{2729, 764},
298
{ 500, 754},{ 809,1108},{ 541,1648},{1523,1385},
299
{ 614,1196},{1209, 847},{ 345,2242},{1442,1747},
300
{ 199, 560},{1092, 194},{ 349,1253},{1653, 507},
301
{ 625, 354},{1376, 431},{1187,1465},{2164, 872},
302
{ 360, 974},{1008, 698},{ 704,1346},{2114, 452},
303
{ 720, 816},{1240,1089},{ 439,2475},{1498,2040},
304
{ 336, 718},{1213, 187},{ 451,1450},{1368, 885},
305
{ 592, 578},{1131, 531},{ 861,1855},{1764,1500},
306
{ 444, 970},{ 935, 903},{ 424,1687},{1633,1102},
307
{ 793, 897},{1060, 897},{ 185,2011},{1205,1855}};
308

    
309
static const qcelp_vector qcelp_lspvq3[128]= {
310
{ 225, 283},{1296, 355},{ 543, 343},{2073, 274},
311
{ 204,1099},{1562, 523},{1388, 161},{2784, 274},
312
{ 112, 849},{1870, 175},{1189, 160},{1490,1088},
313
{ 969,1115},{ 659,3322},{1158,1073},{3183,1363},
314
{ 517, 223},{1740, 223},{ 704, 387},{2637, 234},
315
{ 692,1005},{1287,1610},{ 952, 532},{2393, 646},
316
{ 490, 552},{1619, 657},{ 845, 670},{1784,2280},
317
{ 191,1775},{ 272,2868},{ 942, 952},{2628,1479},
318
{ 278, 579},{1565, 218},{ 814, 180},{2379, 187},
319
{ 276,1444},{1199,1223},{1200, 349},{3009, 307},
320
{ 312, 844},{1898, 306},{ 863, 470},{1685,1241},
321
{ 513,1727},{ 711,2233},{1085, 864},{3398, 527},
322
{ 414, 440},{1356, 612},{ 964, 147},{2173, 738},
323
{ 465,1292},{ 877,1749},{1104, 689},{2105,1311},
324
{ 580, 864},{1895, 752},{ 652, 609},{1485,1699},
325
{ 514,1400},{ 386,2131},{ 933, 798},{2473, 986},
326
{ 334, 360},{1375, 398},{ 621, 276},{2183, 280},
327
{ 311,1114},{1382, 807},{1284, 175},{2605, 636},
328
{ 230, 816},{1739, 408},{1074, 176},{1619,1120},
329
{ 784,1371},{ 448,3050},{1189, 880},{3039,1165},
330
{ 424, 241},{1672, 186},{ 815, 333},{2432, 324},
331
{ 584,1029},{1137,1546},{1015, 585},{2198, 995},
332
{ 574, 581},{1746, 647},{ 733, 740},{1938,1737},
333
{ 347,1710},{ 373,2429},{ 787,1061},{2439,1438},
334
{ 185, 536},{1489, 178},{ 703, 216},{2178, 487},
335
{ 154,1421},{1414, 994},{1103, 352},{3072, 473},
336
{ 408, 819},{2055, 168},{ 998, 354},{1917,1140},
337
{ 665,1799},{ 993,2213},{1234, 631},{3003, 762},
338
{ 373, 620},{1518, 425},{ 913, 300},{1966, 836},
339
{ 402,1185},{ 948,1385},{1121, 555},{1802,1509},
340
{ 474, 886},{1888, 610},{ 739, 585},{1231,2379},
341
{ 661,1335},{ 205,2211},{ 823, 822},{2480,1179}};
342

    
343
static const qcelp_vector qcelp_lspvq4[64]= {
344
{ 348, 311},{ 812,1145},{ 552, 461},{1826, 263},
345
{ 601, 675},{1730, 172},{1523, 193},{2449, 277},
346
{ 334, 668},{ 805,1441},{1319, 207},{1684, 910},
347
{ 582,1318},{1403,1098},{ 979, 832},{2700,1359},
348
{ 624, 228},{1292, 979},{ 800, 195},{2226, 285},
349
{ 730, 862},{1537, 601},{1115, 509},{2720, 354},
350
{ 218,1167},{1212,1538},{1074, 247},{1674,1710},
351
{ 322,2142},{1263, 777},{ 981, 556},{2119,1710},
352
{ 193, 596},{1035, 957},{ 694, 397},{1997, 253},
353
{ 743, 603},{1584, 321},{1346, 346},{2221, 708},
354
{ 451, 732},{1040,1415},{1184, 230},{1853, 919},
355
{ 310,1661},{1625, 706},{ 856, 843},{2902, 702},
356
{ 467, 348},{1108,1048},{ 859, 306},{1964, 463},
357
{ 560,1013},{1425, 533},{1142, 634},{2391, 879},
358
{ 397,1084},{1345,1700},{ 976, 248},{1887,1189},
359
{ 644,2087},{1262, 603},{ 877, 550},{2203,1307}};
360

    
361
static const qcelp_vector qcelp_lspvq5[64]= {
362
{ 360, 222},{ 820,1097},{ 601, 319},{1656, 198},
363
{ 604, 513},{1552, 141},{1391, 155},{2474, 261},
364
{ 269, 785},{1463, 646},{1123, 191},{2015, 223},
365
{ 785, 844},{1202,1011},{ 980, 807},{3014, 793},
366
{ 570, 180},{1135,1382},{ 778, 256},{1901, 179},
367
{ 807, 622},{1461, 458},{1231, 178},{2028, 821},
368
{ 387, 927},{1496,1004},{ 888, 392},{2246, 341},
369
{ 295,1462},{1156, 694},{1022, 473},{2226,1364},
370
{ 210, 478},{1029,1020},{ 722, 181},{1730, 251},
371
{ 730, 488},{1465, 293},{1303, 326},{2595, 387},
372
{ 458, 584},{1569, 742},{1029, 173},{1910, 495},
373
{ 605,1159},{1268, 719},{ 973, 646},{2872, 428},
374
{ 443, 334},{ 835,1465},{ 912, 138},{1716, 442},
375
{ 620, 778},{1316, 450},{1186, 335},{1446,1665},
376
{ 486,1050},{1675,1019},{ 880, 278},{2214, 202},
377
{ 539,1564},{1142, 533},{ 984, 391},{2130,1089}};
378

    
379
static const qcelp_vector * const qcelp_lspvq[5] = {
380
    qcelp_lspvq1,
381
    qcelp_lspvq2,
382
    qcelp_lspvq3,
383
    qcelp_lspvq4,
384
    qcelp_lspvq5
385
};
386

    
387
/**
388
 * the final gain scalefactor before clipping into a usable output float
389
 */
390
#define QCELP_SCALE 8192.
391

    
392
/**
393
 * table for computing Ga (decoded linear codebook gain magnitude)
394
 *
395
 * @note The table could fit in int16_t in x*8 form, but it seems
396
 *       to be slower on x86
397
 *
398
 * TIA/EIA/IS-733 2.4.6.2.1-3
399
 */
400

    
401
static const float qcelp_g12ga[61] = {
402
    1.000/QCELP_SCALE,   1.125/QCELP_SCALE,   1.250/QCELP_SCALE,   1.375/QCELP_SCALE,
403
    1.625/QCELP_SCALE,   1.750/QCELP_SCALE,   2.000/QCELP_SCALE,   2.250/QCELP_SCALE,
404
    2.500/QCELP_SCALE,   2.875/QCELP_SCALE,   3.125/QCELP_SCALE,   3.500/QCELP_SCALE,
405
    4.000/QCELP_SCALE,   4.500/QCELP_SCALE,   5.000/QCELP_SCALE,   5.625/QCELP_SCALE,
406
    6.250/QCELP_SCALE,   7.125/QCELP_SCALE,   8.000/QCELP_SCALE,   8.875/QCELP_SCALE,
407
   10.000/QCELP_SCALE,  11.250/QCELP_SCALE,  12.625/QCELP_SCALE,  14.125/QCELP_SCALE,
408
   15.875/QCELP_SCALE,  17.750/QCELP_SCALE,  20.000/QCELP_SCALE,  22.375/QCELP_SCALE,
409
   25.125/QCELP_SCALE,  28.125/QCELP_SCALE,  31.625/QCELP_SCALE,  35.500/QCELP_SCALE,
410
   39.750/QCELP_SCALE,  44.625/QCELP_SCALE,  50.125/QCELP_SCALE,  56.250/QCELP_SCALE,
411
   63.125/QCELP_SCALE,  70.750/QCELP_SCALE,  79.375/QCELP_SCALE,  89.125/QCELP_SCALE,
412
  100.000/QCELP_SCALE, 112.250/QCELP_SCALE, 125.875/QCELP_SCALE, 141.250/QCELP_SCALE,
413
  158.500/QCELP_SCALE, 177.875/QCELP_SCALE, 199.500/QCELP_SCALE, 223.875/QCELP_SCALE,
414
  251.250/QCELP_SCALE, 281.875/QCELP_SCALE, 316.250/QCELP_SCALE, 354.875/QCELP_SCALE,
415
  398.125/QCELP_SCALE, 446.625/QCELP_SCALE, 501.125/QCELP_SCALE, 563.375/QCELP_SCALE,
416
  631.000/QCELP_SCALE, 708.000/QCELP_SCALE, 794.375/QCELP_SCALE, 891.250/QCELP_SCALE,
417
 1000.000/QCELP_SCALE};
418

    
419
/**
420
 * circular codebook for rate 1 frames in x*100 form
421
 *
422
 * TIA/EIA/IS-733 2.4.6.1-2
423
 */
424
static const int16_t qcelp_rate_full_codebook[128] = {
425
     10,  -65,  -59,   12,  110,   34, -134,  157,
426
    104,  -84,  -34, -115,   23, -101,    3,   45,
427
   -101,  -16,  -59,   28,  -45,  134,  -67,   22,
428
     61,  -29,  226,  -26,  -55, -179,  157,  -51,
429
   -220,  -93,  -37,   60,  118,   74,  -48,  -95,
430
   -181,  111,   36,  -52, -215,   78, -112,   39,
431
    -17,  -47, -223,   19,   12,  -98, -142,  130,
432
     54, -127,   21,  -12,   39,  -48,   12,  128,
433
      6, -167,   82, -102,  -79,   55,  -44,   48,
434
    -20,  -53,    8,  -61,   11,  -70, -157, -168,
435
     20,  -56,  -74,   78,   33,  -63, -173,   -2,
436
    -75,  -53, -146,   77,   66,  -29,    9,  -75,
437
     65,  119,  -43,   76,  233,   98,  125, -156,
438
    -27,   78,   -9,  170,  176,  143, -148,   -7,
439
     27, -136,    5,   27,   18,  139,  204,    7,
440
   -184, -197,   52,   -3,   78, -189,    8,  -65
441
};
442
#define QCELP_RATE_FULL_CODEBOOK_RATIO .01
443

    
444
/**
445
 * circular codebook for rate 1/2 frames in x*2 form
446
 *
447
 * TIA/EIA/IS-733 2.4.6.1-1
448
 */
449
static const int8_t qcelp_rate_half_codebook[128] = {
450
     0, -4,  0, -3,  0,  0,  0,  0,
451
     0,  0,  0,  0,  0,  0,  0,  0,
452
     0, -3, -2,  0,  0,  0,  0,  0,
453
     0,  0,  0,  0,  0,  0,  0,  5,
454
     0,  0,  0,  0,  0,  0,  4,  0,
455
     0,  3,  2,  0,  3,  4,  0,  0,
456
     0,  0,  0,  0,  0,  0,  0,  0,
457
     0,  0,  0,  0,  0,  3,  0,  0,
458
    -3,  3,  0,  0, -2,  0,  3,  0,
459
     0,  0,  0,  0,  0,  0, -5,  0,
460
     0,  0,  0,  3,  0,  0,  0,  3,
461
     0,  0,  0,  0,  0,  0,  0,  4,
462
     0,  0,  0,  0,  0,  0,  0,  0,
463
     0,  3,  6, -3, -4,  0, -3, -3,
464
     3, -3,  0,  0,  0,  0,  0,  0,
465
     0,  0,  0,  0,  0,  0,  0,  0
466
};
467
#define QCELP_RATE_HALF_CODEBOOK_RATIO 0.5
468

    
469
/**
470
 * sqrt(1.887) is the maximum of the pseudorandom
471
 * white sequence used to generate the scaled codebook
472
 * vector for framerate 1/4.
473
 *
474
 * TIA/EIA/IS-733 2.4.8.1.2
475
 */
476
#define QCELP_SQRT1887 1.373681186
477

    
478
/**
479
 * table for impulse response of BPF used to filter
480
 * the white excitation for framerate 1/4 synthesis
481
 *
482
 * Only half the tables are needed because of symetry.
483
 *
484
 * TIA/EIA/IS-733 2.4.8.1.2-1.1
485
 */
486
static const double qcelp_rnd_fir_coefs[11] = {
487
  -1.344519e-1, 1.735384e-2, -6.905826e-2, 2.434368e-2,
488
  -8.210701e-2, 3.041388e-2, -9.251384e-2, 3.501983e-2,
489
  -9.918777e-2, 3.749518e-2,  8.985137e-1
490
};
491

    
492
#endif /* AVCODEC_QCELPDATA_H */