Statistics
| Branch: | Revision:

ffmpeg / libavcodec / qcelpdata.h @ 2912e87a

History | View | Annotate | Download (19.9 KB)

1
/*
2
 * QCELP decoder
3
 * Copyright (c) 2007 Reynaldo H. Verdejo Pinochet
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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
27
 * Data tables for the QCELP decoder
28
 * @author Reynaldo H. Verdejo Pinochet
29
 * @remark Libav merging spearheaded by Kenan Gillet
30
 * @remark Development mentored by Benjamin Larson
31
 */
32

    
33
#include <stddef.h>
34
#include <stdint.h>
35
#include "libavutil/common.h"
36

    
37
/**
38
 * QCELP unpacked data frame
39
 */
40
typedef struct {
41
/// @defgroup qcelp_codebook_parameters QCELP excitation codebook parameters
42
/// @{
43
    uint8_t cbsign[16]; ///!< sign of the codebook gain for each codebook subframe
44
    uint8_t cbgain[16]; ///!< unsigned codebook gain for each codebook subframe
45
    uint8_t cindex[16]; ///!< codebook index for each codebook subframe
46
/// @}
47

    
48
/// @defgroup qcelp_pitch_parameters QCELP pitch prediction parameters
49
/// @{
50
    uint8_t plag[4];    ///!< pitch lag for each pitch subframe
51
    uint8_t pfrac[4];   ///!< fractional pitch lag for each pitch subframe
52
    uint8_t pgain[4];   ///!< pitch gain for each pitch subframe
53
/// @}
54

    
55
    /**
56
     * line spectral pair frequencies (LSP) for RATE_OCTAVE,
57
     * line spectral pair frequencies grouped into five vectors
58
     * of dimension two (LSPV) for other rates
59
     */
60
    uint8_t lspv[10];
61

    
62
    /**
63
     * reserved bits only present in bitrate 1, 1/4 and 1/8 packets
64
     */
65
    uint8_t reserved;
66
} QCELPFrame;
67

    
68
/**
69
 * pre-calculated table for hammsinc function
70
 * Only half of the table is needed because of symmetry.
71
 *
72
 * TIA/EIA/IS-733 2.4.5.2-2/3
73
 */
74
static const float qcelp_hammsinc_table[4] = { -0.006822,  0.041249, -0.143459,  0.588863};
75

    
76
typedef struct {
77
    uint8_t index;  /*!< index into the QCELPContext structure */
78
    uint8_t bitpos; /*!< position of the lowest bit in the value's byte */
79
    uint8_t bitlen; /*!< number of bits to read */
80
} QCELPBitmap;
81

    
82
#define QCELP_OF(variable, bit, len) {offsetof(QCELPFrame, variable), bit, len}
83

    
84
/**
85
 * bitmap unpacking tables for RATE_FULL
86
 *
87
 * TIA/EIA/IS-733 Table 2.4.7.1-1
88
 */
89
static const QCELPBitmap qcelp_rate_full_bitmap[] = {
90
                                // start on bit
91
    QCELP_OF(lspv  [ 2], 0, 3), // 265
92
    QCELP_OF(lspv  [ 1], 0, 7), // 262
93
    QCELP_OF(lspv  [ 0], 0, 6), // 255
94
    QCELP_OF(lspv  [ 4], 0, 6), // 249
95
    QCELP_OF(lspv  [ 3], 0, 6), // 243
96
    QCELP_OF(lspv  [ 2], 3, 4), // 237
97
    QCELP_OF(cbsign[ 0], 0, 1), // 233
98
    QCELP_OF(cbgain[ 0], 0, 4), // 232
99
    QCELP_OF(pfrac [ 0], 0, 1), // 228
100
    QCELP_OF(plag  [ 0], 0, 7), // 227
101
    QCELP_OF(pgain [ 0], 0, 3), // 220
102
    QCELP_OF(cindex[ 1], 0, 4), // 217
103
    QCELP_OF(cbsign[ 1], 0, 1), // 213
104
    QCELP_OF(cbgain[ 1], 0, 4), // 212
105
    QCELP_OF(cindex[ 0], 0, 7), // 208
106
    QCELP_OF(cbgain[ 3], 0, 1), // 201
107
    QCELP_OF(cindex[ 2], 0, 7), // 200
108
    QCELP_OF(cbsign[ 2], 0, 1), // 193
109
    QCELP_OF(cbgain[ 2], 0, 4), // 192
110
    QCELP_OF(cindex[ 1], 4, 3), // 188
111
    QCELP_OF(plag  [ 1], 0, 3), // 185
112
    QCELP_OF(pgain [ 1], 0, 3), // 182
113
    QCELP_OF(cindex[ 3], 0, 7), // 179
114
    QCELP_OF(cbsign[ 3], 0, 1), // 172
115
    QCELP_OF(cbgain[ 3], 1, 2), // 171
116
    QCELP_OF(cindex[ 4], 0, 6), // 169
117
    QCELP_OF(cbsign[ 4], 0, 1), // 163
118
    QCELP_OF(cbgain[ 4], 0, 4), // 162
119
    QCELP_OF(pfrac [ 1], 0, 1), // 158
120
    QCELP_OF(plag  [ 1], 3, 4), // 157
121
    QCELP_OF(cbgain[ 6], 0, 3), // 153
122
    QCELP_OF(cindex[ 5], 0, 7), // 150
123
    QCELP_OF(cbsign[ 5], 0, 1), // 143
124
    QCELP_OF(cbgain[ 5], 0, 4), // 142
125
    QCELP_OF(cindex[ 4], 6, 1), // 138
126
    QCELP_OF(cindex[ 7], 0, 3), // 137
127
    QCELP_OF(cbsign[ 7], 0, 1), // 134
128
    QCELP_OF(cbgain[ 7], 0, 3), // 133
129
    QCELP_OF(cindex[ 6], 0, 7), // 130
130
    QCELP_OF(cbsign[ 6], 0, 1), // 123
131
    QCELP_OF(cbgain[ 6], 3, 1), // 122
132
    QCELP_OF(cbgain[ 8], 0, 1), // 121
133
    QCELP_OF(pfrac [ 2], 0, 1), // 120
134
    QCELP_OF(plag  [ 2], 0, 7), // 119
135
    QCELP_OF(pgain [ 2], 0, 3), // 112
136
    QCELP_OF(cindex[ 7], 3, 4), // 109
137
    QCELP_OF(cbsign[ 9], 0, 1), // 105
138
    QCELP_OF(cbgain[ 9], 0, 4), // 104
139
    QCELP_OF(cindex[ 8], 0, 7), // 100
140
    QCELP_OF(cbsign[ 8], 0, 1), //  93
141
    QCELP_OF(cbgain[ 8], 1, 3), //  92
142
    QCELP_OF(cindex[10], 0, 4), //  89
143
    QCELP_OF(cbsign[10], 0, 1), //  85
144
    QCELP_OF(cbgain[10], 0, 4), //  84
145
    QCELP_OF(cindex[ 9], 0, 7), //  80
146
    QCELP_OF(pgain [ 3], 0, 2), //  73
147
    QCELP_OF(cindex[11], 0, 7), //  71
148
    QCELP_OF(cbsign[11], 0, 1), //  64
149
    QCELP_OF(cbgain[11], 0, 3), //  63
150
    QCELP_OF(cindex[10], 4, 3), //  60
151
    QCELP_OF(cindex[12], 0, 2), //  57
152
    QCELP_OF(cbsign[12], 0, 1), //  55
153
    QCELP_OF(cbgain[12], 0, 4), //  54
154
    QCELP_OF(pfrac [ 3], 0, 1), //  50
155
    QCELP_OF(plag  [ 3], 0, 7), //  49
156
    QCELP_OF(pgain [ 3], 2, 1), //  42
157
    QCELP_OF(cindex[13], 0, 6), //  41
158
    QCELP_OF(cbsign[13], 0, 1), //  35
159
    QCELP_OF(cbgain[13], 0, 4), //  34
160
    QCELP_OF(cindex[12], 2, 5), //  30
161
    QCELP_OF(cbgain[15], 0, 3), //  25
162
    QCELP_OF(cindex[14], 0, 7), //  22
163
    QCELP_OF(cbsign[14], 0, 1), //  15
164
    QCELP_OF(cbgain[14], 0, 4), //  14
165
    QCELP_OF(cindex[13], 6, 1), //  10
166
    QCELP_OF(reserved,   0, 2), //   9
167
    QCELP_OF(cindex[15], 0, 7), //   7
168
    QCELP_OF(cbsign[15], 0, 1)  //   0
169
};
170

    
171
/**
172
 * bitmap unpacking tables for RATE_HALF
173
 *
174
 * TIA/EIA/IS-733 Table 2.4.7.2-1
175
 */
176
static const QCELPBitmap qcelp_rate_half_bitmap[] = {
177
                               // start on bit
178
    QCELP_OF(lspv  [2], 0, 3), // 123
179
    QCELP_OF(lspv  [1], 0, 7), // 120
180
    QCELP_OF(lspv  [0], 0, 6), // 113
181
    QCELP_OF(lspv  [4], 0, 6), // 107
182
    QCELP_OF(lspv  [3], 0, 6), // 101
183
    QCELP_OF(lspv  [2], 3, 4), //  95
184
    QCELP_OF(cbsign[0], 0, 1), //  91
185
    QCELP_OF(cbgain[0], 0, 4), //  90
186
    QCELP_OF(pfrac [0], 0, 1), //  86
187
    QCELP_OF(plag  [0], 0, 7), //  85
188
    QCELP_OF(pgain [0], 0, 3), //  78
189
    QCELP_OF(plag  [1], 0, 6), //  75
190
    QCELP_OF(pgain [1], 0, 3), //  69
191
    QCELP_OF(cindex[0], 0, 7), //  66
192
    QCELP_OF(pgain [2], 0, 2), //  59
193
    QCELP_OF(cindex[1], 0, 7), //  57
194
    QCELP_OF(cbsign[1], 0, 1), //  50
195
    QCELP_OF(cbgain[1], 0, 4), //  49
196
    QCELP_OF(pfrac [1], 0, 1), //  45
197
    QCELP_OF(plag  [1], 6, 1), //  44
198
    QCELP_OF(cindex[2], 0, 2), //  43
199
    QCELP_OF(cbsign[2], 0, 1), //  41
200
    QCELP_OF(cbgain[2], 0, 4), //  40
201
    QCELP_OF(pfrac [2], 0, 1), //  36
202
    QCELP_OF(plag  [2], 0, 7), //  35
203
    QCELP_OF(pgain [2], 2, 1), //  28
204
    QCELP_OF(pfrac [3], 0, 1), //  27
205
    QCELP_OF(plag  [3], 0, 7), //  26
206
    QCELP_OF(pgain [3], 0, 3), //  19
207
    QCELP_OF(cindex[2], 2, 5), //  16
208
    QCELP_OF(cindex[3], 0, 7), //  11
209
    QCELP_OF(cbsign[3], 0, 1), //   4
210
    QCELP_OF(cbgain[3], 0, 4)  //   3
211
};
212

    
213
/**
214
 * bitmap unpacking tables for RATE_QUARTER
215
 *
216
 * TIA/EIA/IS-733 Table 2.4.7.3-1
217
 */
218
static const QCELPBitmap qcelp_rate_quarter_bitmap[] = {
219
                               // start on bit
220
    QCELP_OF(lspv  [2], 0, 3), // 53
221
    QCELP_OF(lspv  [1], 0, 7), // 50
222
    QCELP_OF(lspv  [0], 0, 6), // 43
223
    QCELP_OF(lspv  [4], 0, 6), // 37
224
    QCELP_OF(lspv  [3], 0, 6), // 31
225
    QCELP_OF(lspv  [2], 3, 4), // 25
226
    QCELP_OF(cbgain[3], 0, 4), // 21
227
    QCELP_OF(cbgain[2], 0, 4), // 17
228
    QCELP_OF(cbgain[1], 0, 4), // 13
229
    QCELP_OF(cbgain[0], 0, 4), //  9
230
    QCELP_OF(reserved,  0, 2), //  5
231
    QCELP_OF(cbgain[4], 0, 4)  //  3
232
};
233

    
234
/**
235
 * bitmap unpacking tables for RATE_OCTAVE
236
 *
237
 * trick: CBSEED is written into QCELPContext.cbsign[15],
238
 * which is not used for RATE_OCTAVE.
239
 * CBSEED is only used to ensure the occurrence of random bit
240
 * patterns in the 16 first bits that are used as the seed.
241
 *
242
 * TIA/EIA/IS-733 Table 2.4.7.4-1
243
 */
244
static const QCELPBitmap qcelp_rate_octave_bitmap[] = {
245
                                // start on bit
246
    QCELP_OF(cbsign[15], 3, 1), // 19
247
    QCELP_OF(lspv   [0], 0, 1), // 18
248
    QCELP_OF(lspv   [1], 0, 1), // 17
249
    QCELP_OF(lspv   [2], 0, 1), // 16
250
    QCELP_OF(cbsign[15], 2, 1), // 15
251
    QCELP_OF(lspv   [3], 0, 1), // 14
252
    QCELP_OF(lspv   [4], 0, 1), // 13
253
    QCELP_OF(lspv   [5], 0, 1), // 12
254
    QCELP_OF(cbsign[15], 1, 1), // 11
255
    QCELP_OF(lspv   [6], 0, 1), // 10
256
    QCELP_OF(lspv   [7], 0, 1), //  9
257
    QCELP_OF(lspv   [8], 0, 1), //  8
258
    QCELP_OF(cbsign[15], 0, 1), //  7
259
    QCELP_OF(lspv   [9], 0, 1), //  6
260
    QCELP_OF(cbgain [0], 0, 2), //  7
261
    QCELP_OF(reserved,   0, 4)  //  3
262
};
263

    
264
/**
265
 * position of the bitmapping data for each packet type in
266
 * the QCELPContext
267
 */
268
static const QCELPBitmap * const qcelp_unpacking_bitmaps_per_rate[5] = {
269
    NULL,                     ///!< for SILENCE rate
270
    qcelp_rate_octave_bitmap,
271
    qcelp_rate_quarter_bitmap,
272
    qcelp_rate_half_bitmap,
273
    qcelp_rate_full_bitmap,
274
};
275

    
276
static const uint16_t qcelp_unpacking_bitmaps_lengths[5] = {
277
    0, ///!< for SILENCE rate
278
    FF_ARRAY_ELEMS(qcelp_rate_octave_bitmap),
279
    FF_ARRAY_ELEMS(qcelp_rate_quarter_bitmap),
280
    FF_ARRAY_ELEMS(qcelp_rate_half_bitmap),
281
    FF_ARRAY_ELEMS(qcelp_rate_full_bitmap),
282
};
283

    
284
typedef uint16_t qcelp_vector[2];
285

    
286
/**
287
 * LSP vector quantization tables in x*10000 form
288
 *
289
 * TIA/EIA/IS-733 tables 2.4.3.2.6.3-1 through 2.4.3.2.6.3-5
290
 */
291

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

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

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

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

    
396
static const qcelp_vector qcelp_lspvq5[64]= {
397
{ 360, 222},{ 820,1097},{ 601, 319},{1656, 198},
398
{ 604, 513},{1552, 141},{1391, 155},{2474, 261},
399
{ 269, 785},{1463, 646},{1123, 191},{2015, 223},
400
{ 785, 844},{1202,1011},{ 980, 807},{3014, 793},
401
{ 570, 180},{1135,1382},{ 778, 256},{1901, 179},
402
{ 807, 622},{1461, 458},{1231, 178},{2028, 821},
403
{ 387, 927},{1496,1004},{ 888, 392},{2246, 341},
404
{ 295,1462},{1156, 694},{1022, 473},{2226,1364},
405
{ 210, 478},{1029,1020},{ 722, 181},{1730, 251},
406
{ 730, 488},{1465, 293},{1303, 326},{2595, 387},
407
{ 458, 584},{1569, 742},{1029, 173},{1910, 495},
408
{ 605,1159},{1268, 719},{ 973, 646},{2872, 428},
409
{ 443, 334},{ 835,1465},{ 912, 138},{1716, 442},
410
{ 620, 778},{1316, 450},{1186, 335},{1446,1665},
411
{ 486,1050},{1675,1019},{ 880, 278},{2214, 202},
412
{ 539,1564},{1142, 533},{ 984, 391},{2130,1089}};
413

    
414
static const qcelp_vector * const qcelp_lspvq[5] = {
415
    qcelp_lspvq1,
416
    qcelp_lspvq2,
417
    qcelp_lspvq3,
418
    qcelp_lspvq4,
419
    qcelp_lspvq5
420
};
421

    
422
/**
423
 * the final gain scalefactor before clipping into a usable output float
424
 */
425
#define QCELP_SCALE 8192.
426

    
427
/**
428
 * table for computing Ga (decoded linear codebook gain magnitude)
429
 *
430
 * @note The table could fit in int16_t in x*8 form, but it seems
431
 *       to be slower on x86
432
 *
433
 * TIA/EIA/IS-733 2.4.6.2.1-3
434
 */
435

    
436
static const float qcelp_g12ga[61] = {
437
    1.000/QCELP_SCALE,   1.125/QCELP_SCALE,   1.250/QCELP_SCALE,   1.375/QCELP_SCALE,
438
    1.625/QCELP_SCALE,   1.750/QCELP_SCALE,   2.000/QCELP_SCALE,   2.250/QCELP_SCALE,
439
    2.500/QCELP_SCALE,   2.875/QCELP_SCALE,   3.125/QCELP_SCALE,   3.500/QCELP_SCALE,
440
    4.000/QCELP_SCALE,   4.500/QCELP_SCALE,   5.000/QCELP_SCALE,   5.625/QCELP_SCALE,
441
    6.250/QCELP_SCALE,   7.125/QCELP_SCALE,   8.000/QCELP_SCALE,   8.875/QCELP_SCALE,
442
   10.000/QCELP_SCALE,  11.250/QCELP_SCALE,  12.625/QCELP_SCALE,  14.125/QCELP_SCALE,
443
   15.875/QCELP_SCALE,  17.750/QCELP_SCALE,  20.000/QCELP_SCALE,  22.375/QCELP_SCALE,
444
   25.125/QCELP_SCALE,  28.125/QCELP_SCALE,  31.625/QCELP_SCALE,  35.500/QCELP_SCALE,
445
   39.750/QCELP_SCALE,  44.625/QCELP_SCALE,  50.125/QCELP_SCALE,  56.250/QCELP_SCALE,
446
   63.125/QCELP_SCALE,  70.750/QCELP_SCALE,  79.375/QCELP_SCALE,  89.125/QCELP_SCALE,
447
  100.000/QCELP_SCALE, 112.250/QCELP_SCALE, 125.875/QCELP_SCALE, 141.250/QCELP_SCALE,
448
  158.500/QCELP_SCALE, 177.875/QCELP_SCALE, 199.500/QCELP_SCALE, 223.875/QCELP_SCALE,
449
  251.250/QCELP_SCALE, 281.875/QCELP_SCALE, 316.250/QCELP_SCALE, 354.875/QCELP_SCALE,
450
  398.125/QCELP_SCALE, 446.625/QCELP_SCALE, 501.125/QCELP_SCALE, 562.375/QCELP_SCALE,
451
  631.000/QCELP_SCALE, 708.000/QCELP_SCALE, 794.375/QCELP_SCALE, 891.250/QCELP_SCALE,
452
 1000.000/QCELP_SCALE};
453

    
454
/**
455
 * circular codebook for rate 1 frames in x*100 form
456
 *
457
 * TIA/EIA/IS-733 2.4.6.1-2
458
 */
459
static const int16_t qcelp_rate_full_codebook[128] = {
460
     10,  -65,  -59,   12,  110,   34, -134,  157,
461
    104,  -84,  -34, -115,   23, -101,    3,   45,
462
   -101,  -16,  -59,   28,  -45,  134,  -67,   22,
463
     61,  -29,  226,  -26,  -55, -179,  157,  -51,
464
   -220,  -93,  -37,   60,  118,   74,  -48,  -95,
465
   -181,  111,   36,  -52, -215,   78, -112,   39,
466
    -17,  -47, -223,   19,   12,  -98, -142,  130,
467
     54, -127,   21,  -12,   39,  -48,   12,  128,
468
      6, -167,   82, -102,  -79,   55,  -44,   48,
469
    -20,  -53,    8,  -61,   11,  -70, -157, -168,
470
     20,  -56,  -74,   78,   33,  -63, -173,   -2,
471
    -75,  -53, -146,   77,   66,  -29,    9,  -75,
472
     65,  119,  -43,   76,  233,   98,  125, -156,
473
    -27,   78,   -9,  170,  176,  143, -148,   -7,
474
     27, -136,    5,   27,   18,  139,  204,    7,
475
   -184, -197,   52,   -3,   78, -189,    8,  -65
476
};
477
#define QCELP_RATE_FULL_CODEBOOK_RATIO .01
478

    
479
/**
480
 * circular codebook for rate 1/2 frames in x*2 form
481
 *
482
 * TIA/EIA/IS-733 2.4.6.1-1
483
 */
484
static const int8_t qcelp_rate_half_codebook[128] = {
485
     0, -4,  0, -3,  0,  0,  0,  0,
486
     0,  0,  0,  0,  0,  0,  0,  0,
487
     0, -3, -2,  0,  0,  0,  0,  0,
488
     0,  0,  0,  0,  0,  0,  0,  5,
489
     0,  0,  0,  0,  0,  0,  4,  0,
490
     0,  3,  2,  0,  3,  4,  0,  0,
491
     0,  0,  0,  0,  0,  0,  0,  0,
492
     0,  0,  0,  0,  0,  3,  0,  0,
493
    -3,  3,  0,  0, -2,  0,  3,  0,
494
     0,  0,  0,  0,  0,  0, -5,  0,
495
     0,  0,  0,  3,  0,  0,  0,  3,
496
     0,  0,  0,  0,  0,  0,  0,  4,
497
     0,  0,  0,  0,  0,  0,  0,  0,
498
     0,  3,  6, -3, -4,  0, -3, -3,
499
     3, -3,  0,  0,  0,  0,  0,  0,
500
     0,  0,  0,  0,  0,  0,  0,  0
501
};
502
#define QCELP_RATE_HALF_CODEBOOK_RATIO 0.5
503

    
504
/**
505
 * sqrt(1.887) is the maximum of the pseudorandom
506
 * white sequence used to generate the scaled codebook
507
 * vector for bitrate 1/4.
508
 *
509
 * TIA/EIA/IS-733 2.4.8.1.2
510
 */
511
#define QCELP_SQRT1887 1.373681186
512

    
513
/**
514
 * table for impulse response of BPF used to filter
515
 * the white excitation for bitrate 1/4 synthesis
516
 *
517
 * Only half the tables are needed because of symmetry.
518
 *
519
 * TIA/EIA/IS-733 2.4.8.1.2-1.1
520
 */
521
static const double qcelp_rnd_fir_coefs[11] = {
522
  -1.344519e-1, 1.735384e-2, -6.905826e-2, 2.434368e-2,
523
  -8.210701e-2, 3.041388e-2, -9.251384e-2, 3.501983e-2,
524
  -9.918777e-2, 3.749518e-2,  8.985137e-1
525
};
526

    
527
/**
528
 * This spread factor is used, for bitrate 1/8 and I_F_Q,
529
 * to force the LSP frequencies to be at least 80 Hz apart.
530
 *
531
 * TIA/EIA/IS-733 2.4.3.3.2
532
 */
533
#define QCELP_LSP_SPREAD_FACTOR 0.02
534

    
535
/**
536
 * predictor coefficient for the conversion of LSP codes
537
 * to LSP frequencies for 1/8 and I_F_Q
538
 *
539
 * TIA/EIA/IS-733 2.4.3.2.7-2
540
 */
541
#define QCELP_LSP_OCTAVE_PREDICTOR 29.0/32
542

    
543
/**
544
 * initial coefficient to perform bandwidth expansion on LPC
545
 *
546
 * @note: 0.9883 looks like an approximation of 253/256.
547
 *
548
 * TIA/EIA/IS-733 2.4.3.3.6 6
549
 */
550
#define QCELP_BANDWIDTH_EXPANSION_COEFF 0.9883
551

    
552
#endif /* AVCODEC_QCELPDATA_H */