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