FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
qcelpdata.h
Go to the documentation of this file.
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
27  * Data tables for the QCELP decoder
28  * @author Reynaldo H. Verdejo Pinochet
29  * @remark FFmpeg 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 QCELPFrame {
41 /// @name 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 /// @name 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 QCELPBitmap {
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), // 5
261  QCELP_OF(reserved, 0, 4) // 3
262 };
263 
264 /**
265  * Bitmapping data position 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 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 */
NULL
#define NULL
Definition: coverity.c:32
qcelp_lspvq2
static const qcelp_vector qcelp_lspvq2[128]
Definition: qcelpdata.h:310
QCELPFrame::pfrac
uint8_t pfrac[4]
fractional pitch lag for each pitch subframe
Definition: qcelpdata.h:51
qcelp_rate_half_codebook
static const int8_t qcelp_rate_half_codebook[128]
Circular codebook for rate 1/2 frames in x*2 form.
Definition: qcelpdata.h:484
qcelp_hammsinc_table
static const float qcelp_hammsinc_table[4]
Pre-calculated table for hammsinc function.
Definition: qcelpdata.h:74
QCELPBitmap::index
uint8_t index
index into the QCELPContext structure
Definition: qcelpdata.h:77
QCELPFrame
QCELP unpacked data frame.
Definition: qcelpdata.h:40
QCELPFrame::cindex
uint8_t cindex[16]
codebook index for each codebook subframe
Definition: qcelpdata.h:45
qcelp_lspvq5
static const qcelp_vector qcelp_lspvq5[64]
Definition: qcelpdata.h:396
uint8_t
uint8_t
Definition: audio_convert.c:194
QCELP_OF
#define QCELP_OF(variable, bit, len)
Definition: qcelpdata.h:82
qcelp_lspvq4
static const qcelp_vector qcelp_lspvq4[64]
Definition: qcelpdata.h:378
qcelp_lspvq
static const qcelp_vector *const qcelp_lspvq[5]
Definition: qcelpdata.h:414
qcelp_rate_octave_bitmap
static const QCELPBitmap qcelp_rate_octave_bitmap[]
Bitmap unpacking tables for RATE_OCTAVE.
Definition: qcelpdata.h:244
QCELP_SCALE
#define QCELP_SCALE
The final gain scalefactor before clipping into a usable output float.
Definition: qcelpdata.h:425
QCELPFrame::plag
uint8_t plag[4]
pitch lag for each pitch subframe
Definition: qcelpdata.h:50
QCELPFrame::cbsign
uint8_t cbsign[16]
sign of the codebook gain for each codebook subframe
Definition: qcelpdata.h:43
QCELPFrame::lspv
uint8_t lspv[10]
line spectral pair frequencies (LSP) for RATE_OCTAVE, line spectral pair frequencies grouped into fiv...
Definition: qcelpdata.h:60
qcelp_rate_half_bitmap
static const QCELPBitmap qcelp_rate_half_bitmap[]
Bitmap unpacking tables for RATE_HALF.
Definition: qcelpdata.h:176
qcelp_rate_full_codebook
static const int16_t qcelp_rate_full_codebook[128]
Circular codebook for rate 1 frames in x*100 form.
Definition: qcelpdata.h:459
QCELPFrame::pgain
uint8_t pgain[4]
pitch gain for each pitch subframe
Definition: qcelpdata.h:52
qcelp_lspvq3
static const qcelp_vector qcelp_lspvq3[128]
Definition: qcelpdata.h:344
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:36
QCELPBitmap::bitpos
uint8_t bitpos
position of the lowest bit in the value's byte
Definition: qcelpdata.h:78
qcelp_unpacking_bitmaps_lengths
static const uint16_t qcelp_unpacking_bitmaps_lengths[5]
Definition: qcelpdata.h:276
QCELPBitmap::bitlen
uint8_t bitlen
number of bits to read
Definition: qcelpdata.h:79
qcelp_lspvq1
static const qcelp_vector qcelp_lspvq1[64]
LSP vector quantization tables in x*10000 form.
Definition: qcelpdata.h:292
qcelp_unpacking_bitmaps_per_rate
static const QCELPBitmap *const qcelp_unpacking_bitmaps_per_rate[5]
Bitmapping data position for each packet type in the QCELPContext.
Definition: qcelpdata.h:268
QCELPFrame::reserved
uint8_t reserved
reserved bits only present in bitrate 1, 1/4 and 1/8 packets
Definition: qcelpdata.h:65
qcelp_rate_full_bitmap
static const QCELPBitmap qcelp_rate_full_bitmap[]
Bitmap unpacking tables for RATE_FULL.
Definition: qcelpdata.h:89
qcelp_vector
uint16_t qcelp_vector[2]
Definition: qcelpdata.h:284
common.h
common internal and external API header
qcelp_rate_quarter_bitmap
static const QCELPBitmap qcelp_rate_quarter_bitmap[]
Bitmap unpacking tables for RATE_QUARTER.
Definition: qcelpdata.h:218
qcelp_rnd_fir_coefs
static const double qcelp_rnd_fir_coefs[11]
Table for impulse response of BPF used to filter the white excitation for bitrate 1/4 synthesis...
Definition: qcelpdata.h:521
QCELPFrame::cbgain
uint8_t cbgain[16]
unsigned codebook gain for each codebook subframe
Definition: qcelpdata.h:44
qcelp_g12ga
static const float qcelp_g12ga[61]
Table for computing Ga (decoded linear codebook gain magnitude)
Definition: qcelpdata.h:436
Generated on Thu Oct 27 2016 19:33:30 for FFmpeg by   doxygen 1.8.6