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