falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
44689 Commits
32 Branches
824MB
Tree: c5714b51aa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c5714b51aa'
${ noResults }
FFmpeg/libavcodec/opus_silk.c

1598 lines
59KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2012 Andrew D'Addesio

  3.  * Copyright (c) 2013-2014 Mozilla Corporation

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

  23.  * @file

  24.  * Opus SILK decoder

  25.  */

  26. 

  27. #include <stdint.h>

  28. 

  29. #include "opus.h"

  30. 

  31. typedef struct SilkFrame {

  32.     int coded;

  33.     int log_gain;

  34.     int16_t nlsf[16];

  35.     float    lpc[16];

  36. 

  37.     float output     [2 * SILK_HISTORY];

  38.     float lpc_history[2 * SILK_HISTORY];

  39.     int primarylag;

  40. 

  41.     int prev_voiced;

  42. } SilkFrame;

  43. 

  44. struct SilkContext {

  45.     AVCodecContext *avctx;

  46.     int output_channels;

  47. 

  48.     int midonly;

  49.     int subframes;

  50.     int sflength;

  51.     int flength;

  52.     int nlsf_interp_factor;

  53. 

  54.     enum OpusBandwidth bandwidth;

  55.     int wb;

  56. 

  57.     SilkFrame frame[2];

  58.     float prev_stereo_weights[2];

  59.     float stereo_weights[2];

  60. 

  61.     int prev_coded_channels;

  62. };

  63. 

  64. static const uint16_t silk_model_stereo_s1[] = {

  65.     256,   7,   9,  10,  11,  12,  22,  46,  54,  55,  56,  59,  82, 174, 197, 200,

  66.     201, 202, 210, 234, 244, 245, 246, 247, 249, 256

  67. };

  68. 

  69. static const uint16_t silk_model_stereo_s2[] = {256, 85, 171, 256};

  70. 

  71. static const uint16_t silk_model_stereo_s3[] = {256, 51, 102, 154, 205, 256};

  72. 

  73. static const uint16_t silk_model_mid_only[] = {256, 192, 256};

  74. 

  75. static const uint16_t silk_model_frame_type_inactive[] = {256, 26, 256};

  76. 

  77. static const uint16_t silk_model_frame_type_active[] = {256, 24, 98, 246, 256};

  78. 

  79. static const uint16_t silk_model_gain_highbits[3][9] = {

  80.     {256,  32, 144, 212, 241, 253, 254, 255, 256},

  81.     {256,   2,  19,  64, 124, 186, 233, 252, 256},

  82.     {256,   1,   4,  30, 101, 195, 245, 254, 256}

  83. };

  84. 

  85. static const uint16_t silk_model_gain_lowbits[] = {256, 32, 64, 96, 128, 160, 192, 224, 256};

  86. 

  87. static const uint16_t silk_model_gain_delta[] = {

  88.     256,   6,  11,  22,  53, 185, 206, 214, 218, 221, 223, 225, 227, 228, 229, 230,

  89.     231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,

  90.     247, 248, 249, 250, 251, 252, 253, 254, 255, 256

  91. };

  92. static const uint16_t silk_model_lsf_s1[2][2][33] = {

  93.     {

  94.         {    // NB or MB, unvoiced

  95.             256,  44,  78, 108, 127, 148, 160, 171, 174, 177, 179, 195, 197, 199, 200, 205,

  96.             207, 208, 211, 214, 215, 216, 218, 220, 222, 225, 226, 235, 244, 246, 253, 255, 256

  97.         }, { // NB or MB, voiced

  98.             256,   1,  11,  12,  20,  23,  31,  39,  53,  66,  80,  81,  95, 107, 120, 131,

  99.             142, 154, 165, 175, 185, 196, 204, 213, 221, 228, 236, 237, 238, 244, 245, 251, 256

  100.         }

  101.     }, {

  102.         {    // WB, unvoiced

  103.             256,  31,  52,  55,  72,  73,  81,  98, 102, 103, 121, 137, 141, 143, 146, 147,

  104.             157, 158, 161, 177, 188, 204, 206, 208, 211, 213, 224, 225, 229, 238, 246, 253, 256

  105.         }, { // WB, voiced

  106.             256,   1,   5,  21,  26,  44,  55,  60,  74,  89,  90,  93, 105, 118, 132, 146,

  107.             152, 166, 178, 180, 186, 187, 199, 211, 222, 232, 235, 245, 250, 251, 252, 253, 256

  108.         }

  109.     }

  110. };

  111. 

  112. static const uint16_t silk_model_lsf_s2[32][10] = {

  113.     // NB, MB

  114.     { 256,   1,   2,   3,  18, 242, 253, 254, 255, 256 },

  115.     { 256,   1,   2,   4,  38, 221, 253, 254, 255, 256 },

  116.     { 256,   1,   2,   6,  48, 197, 252, 254, 255, 256 },

  117.     { 256,   1,   2,  10,  62, 185, 246, 254, 255, 256 },

  118.     { 256,   1,   4,  20,  73, 174, 248, 254, 255, 256 },

  119.     { 256,   1,   4,  21,  76, 166, 239, 254, 255, 256 },

  120.     { 256,   1,   8,  32,  85, 159, 226, 252, 255, 256 },

  121.     { 256,   1,   2,  20,  83, 161, 219, 249, 255, 256 },

  122. 

  123.     // WB

  124.     { 256,   1,   2,   3,  12, 244, 253, 254, 255, 256 },

  125.     { 256,   1,   2,   4,  32, 218, 253, 254, 255, 256 },

  126.     { 256,   1,   2,   5,  47, 199, 252, 254, 255, 256 },

  127.     { 256,   1,   2,  12,  61, 187, 252, 254, 255, 256 },

  128.     { 256,   1,   5,  24,  72, 172, 249, 254, 255, 256 },

  129.     { 256,   1,   2,  16,  70, 170, 242, 254, 255, 256 },

  130.     { 256,   1,   2,  17,  78, 165, 226, 251, 255, 256 },

  131.     { 256,   1,   8,  29,  79, 156, 237, 254, 255, 256 }

  132. };

  133. 

  134. static const uint16_t silk_model_lsf_s2_ext[] = { 256, 156, 216, 240, 249, 253, 255, 256 };

  135. 

  136. static const uint16_t silk_model_lsf_interpolation_offset[] = { 256, 13, 35, 64, 75, 256 };

  137. 

  138. static const uint16_t silk_model_pitch_highbits[] = {

  139.     256,   3,   6,  12,  23,  44,  74, 106, 125, 136, 146, 158, 171, 184, 196, 207,

  140.     216, 224, 231, 237, 241, 243, 245, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256

  141. };

  142. 

  143. static const uint16_t silk_model_pitch_lowbits_nb[]= { 256, 64, 128, 192, 256 };

  144. 

  145. static const uint16_t silk_model_pitch_lowbits_mb[]= { 256, 43, 85, 128, 171, 213, 256 };

  146. 

  147. static const uint16_t silk_model_pitch_lowbits_wb[]= { 256, 32, 64, 96, 128, 160, 192, 224, 256 };

  148. 

  149. static const uint16_t silk_model_pitch_delta[] = {

  150.     256,  46,  48,  50,  53,  57,  63,  73,  88, 114, 152, 182, 204, 219, 229, 236,

  151.     242, 246, 250, 252, 254, 256

  152. };

  153. 

  154. static const uint16_t silk_model_pitch_contour_nb10ms[] = { 256, 143, 193, 256 };

  155. 

  156. static const uint16_t silk_model_pitch_contour_nb20ms[] = {

  157.     256,  68,  80, 101, 118, 137, 159, 189, 213, 230, 246, 256

  158. };

  159. 

  160. static const uint16_t silk_model_pitch_contour_mbwb10ms[] = {

  161.     256,  91, 137, 176, 195, 209, 221, 229, 236, 242, 247, 252, 256

  162. };

  163. 

  164. static const uint16_t silk_model_pitch_contour_mbwb20ms[] = {

  165.     256,  33,  55,  73,  89, 104, 118, 132, 145, 158, 168, 177, 186, 194, 200, 206,

  166.     212, 217, 221, 225, 229, 232, 235, 238, 240, 242, 244, 246, 248, 250, 252, 253,

  167.     254, 255, 256

  168. };

  169. 

  170. static const uint16_t silk_model_ltp_filter[] = { 256, 77, 157, 256 };

  171. 

  172. static const uint16_t silk_model_ltp_filter0_sel[] = {

  173.     256, 185, 200, 213, 226, 235, 244, 250, 256

  174. };

  175. 

  176. static const uint16_t silk_model_ltp_filter1_sel[] = {

  177.     256,  57,  91, 112, 132, 147, 160, 172, 185, 195, 205, 214, 224, 233, 241, 248, 256

  178. };

  179. 

  180. static const uint16_t silk_model_ltp_filter2_sel[] = {

  181.     256,  15,  31,  45,  57,  69,  81,  92, 103, 114, 124, 133, 142, 151, 160, 168,

  182.     176, 184, 192, 199, 206, 212, 218, 223, 227, 232, 236, 240, 244, 247, 251, 254, 256

  183. };

  184. 

  185. static const uint16_t silk_model_ltp_scale_index[] = { 256, 128, 192, 256 };

  186. 

  187. static const uint16_t silk_model_lcg_seed[] = { 256, 64, 128, 192, 256 };

  188. 

  189. static const uint16_t silk_model_exc_rate[2][10] = {

  190.     { 256,  15,  66,  78, 124, 169, 182, 215, 242, 256 }, // unvoiced

  191.     { 256,  33,  63,  99, 116, 150, 199, 217, 238, 256 }  // voiced

  192. };

  193. 

  194. static const uint16_t silk_model_pulse_count[11][19] = {

  195.     { 256, 131, 205, 230, 238, 241, 244, 245, 246,

  196.       247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },

  197.     { 256,  58, 151, 211, 234, 241, 244, 245, 246,

  198.       247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },

  199.     { 256,  43,  94, 140, 173, 197, 213, 224, 232,

  200.       238, 241, 244, 247, 249, 250, 251, 253, 254, 256 },

  201.     { 256,  17,  69, 140, 197, 228, 240, 245, 246,

  202.       247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },

  203.     { 256,   6,  27,  68, 121, 170, 205, 226, 237,

  204.       243, 246, 248, 250, 251, 252, 253, 254, 255, 256 },

  205.     { 256,   7,  21,  43,  71, 100, 128, 153, 173,

  206.       190, 203, 214, 223, 230, 235, 239, 243, 246, 256 },

  207.     { 256,   2,   7,  21,  50,  92, 138, 179, 210,

  208.       229, 240, 246, 249, 251, 252, 253, 254, 255, 256 },

  209.     { 256,   1,   3,   7,  17,  36,  65, 100, 137,

  210.       171, 199, 219, 233, 241, 246, 250, 252, 254, 256 },

  211.     { 256,   1,   3,   5,  10,  19,  33,  53,  77,

  212.       104, 132, 158, 181, 201, 216, 227, 235, 241, 256 },

  213.     { 256,   1,   2,   3,   9,  36,  94, 150, 189,

  214.       214, 228, 238, 244, 247, 250, 252, 253, 254, 256 },

  215.     { 256,   2,   3,   9,  36,  94, 150, 189, 214,

  216.       228, 238, 244, 247, 250, 252, 253, 254, 256, 256 }

  217. };

  218. 

  219. static const uint16_t silk_model_pulse_location[4][168] = {

  220.     {

  221.         256, 126, 256,

  222.         256, 56, 198, 256,

  223.         256, 25, 126, 230, 256,

  224.         256, 12, 72, 180, 244, 256,

  225.         256, 7, 42, 126, 213, 250, 256,

  226.         256, 4, 24, 83, 169, 232, 253, 256,

  227.         256, 3, 15, 53, 125, 200, 242, 254, 256,

  228.         256, 2, 10, 35, 89, 162, 221, 248, 255, 256,

  229.         256, 2, 7, 24, 63, 126, 191, 233, 251, 255, 256,

  230.         256, 1, 5, 17, 45, 94, 157, 211, 241, 252, 255, 256,

  231.         256, 1, 5, 13, 33, 70, 125, 182, 223, 245, 253, 255, 256,

  232.         256, 1, 4, 11, 26, 54, 98, 151, 199, 232, 248, 254, 255, 256,

  233.         256, 1, 3, 9, 21, 42, 77, 124, 172, 212, 237, 249, 254, 255, 256,

  234.         256, 1, 2, 6, 16, 33, 60, 97, 144, 187, 220, 241, 250, 254, 255, 256,

  235.         256, 1, 2, 3, 11, 25, 47, 80, 120, 163, 201, 229, 245, 253, 254, 255, 256,

  236.         256, 1, 2, 3, 4, 17, 35, 62, 98, 139, 180, 214, 238, 252, 253, 254, 255, 256

  237.     },{

  238.         256, 127, 256,

  239.         256, 53, 202, 256,

  240.         256, 22, 127, 233, 256,

  241.         256, 11, 72, 183, 246, 256,

  242.         256, 6, 41, 127, 215, 251, 256,

  243.         256, 4, 24, 83, 170, 232, 253, 256,

  244.         256, 3, 16, 56, 127, 200, 241, 254, 256,

  245.         256, 3, 12, 39, 92, 162, 218, 246, 255, 256,

  246.         256, 3, 11, 30, 67, 124, 185, 229, 249, 255, 256,

  247.         256, 3, 10, 25, 53, 97, 151, 200, 233, 250, 255, 256,

  248.         256, 1, 8, 21, 43, 77, 123, 171, 209, 237, 251, 255, 256,

  249.         256, 1, 2, 13, 35, 62, 97, 139, 186, 219, 244, 254, 255, 256,

  250.         256, 1, 2, 8, 22, 48, 85, 128, 171, 208, 234, 248, 254, 255, 256,

  251.         256, 1, 2, 6, 16, 36, 67, 107, 149, 189, 220, 240, 250, 254, 255, 256,

  252.         256, 1, 2, 5, 13, 29, 55, 90, 128, 166, 201, 227, 243, 251, 254, 255, 256,

  253.         256, 1, 2, 4, 10, 22, 43, 73, 109, 147, 183, 213, 234, 246, 252, 254, 255, 256

  254.     },{

  255.         256, 127, 256,

  256.         256, 49, 206, 256,

  257.         256, 20, 127, 236, 256,

  258.         256, 11, 71, 184, 246, 256,

  259.         256, 7, 43, 127, 214, 250, 256,

  260.         256, 6, 30, 87, 169, 229, 252, 256,

  261.         256, 5, 23, 62, 126, 194, 236, 252, 256,

  262.         256, 6, 20, 49, 96, 157, 209, 239, 253, 256,

  263.         256, 1, 16, 39, 74, 125, 175, 215, 245, 255, 256,

  264.         256, 1, 2, 23, 55, 97, 149, 195, 236, 254, 255, 256,

  265.         256, 1, 7, 23, 50, 86, 128, 170, 206, 233, 249, 255, 256,

  266.         256, 1, 6, 18, 39, 70, 108, 148, 186, 217, 238, 250, 255, 256,

  267.         256, 1, 4, 13, 30, 56, 90, 128, 166, 200, 226, 243, 252, 255, 256,

  268.         256, 1, 4, 11, 25, 47, 76, 110, 146, 180, 209, 231, 245, 252, 255, 256,

  269.         256, 1, 3, 8, 19, 37, 62, 93, 128, 163, 194, 219, 237, 248, 253, 255, 256,

  270.         256, 1, 2, 6, 15, 30, 51, 79, 111, 145, 177, 205, 226, 241, 250, 254, 255, 256

  271.     },{

  272.         256, 128, 256,

  273.         256, 42, 214, 256,

  274.         256, 21, 128, 235, 256,

  275.         256, 12, 72, 184, 245, 256,

  276.         256, 8, 42, 128, 214, 249, 256,

  277.         256, 8, 31, 86, 176, 231, 251, 256,

  278.         256, 5, 20, 58, 130, 202, 238, 253, 256,

  279.         256, 6, 18, 45, 97, 174, 221, 241, 251, 256,

  280.         256, 6, 25, 53, 88, 128, 168, 203, 231, 250, 256,

  281.         256, 4, 18, 40, 71, 108, 148, 185, 216, 238, 252, 256,

  282.         256, 3, 13, 31, 57, 90, 128, 166, 199, 225, 243, 253, 256,

  283.         256, 2, 10, 23, 44, 73, 109, 147, 183, 212, 233, 246, 254, 256,

  284.         256, 1, 6, 16, 33, 58, 90, 128, 166, 198, 223, 240, 250, 255, 256,

  285.         256, 1, 5, 12, 25, 46, 75, 110, 146, 181, 210, 231, 244, 251, 255, 256,

  286.         256, 1, 3, 8, 18, 35, 60, 92, 128, 164, 196, 221, 238, 248, 253, 255, 256,

  287.         256, 1, 3, 7, 14, 27, 48, 76, 110, 146, 180, 208, 229, 242, 249, 253, 255, 256

  288.     }

  289. };

  290. 

  291. static const uint16_t silk_model_excitation_lsb[] = {256, 136, 256};

  292. 

  293. static const uint16_t silk_model_excitation_sign[3][2][7][3] = {

  294.     {    // Inactive

  295.         {    // Low offset

  296.             {256,   2, 256},

  297.             {256, 207, 256},

  298.             {256, 189, 256},

  299.             {256, 179, 256},

  300.             {256, 174, 256},

  301.             {256, 163, 256},

  302.             {256, 157, 256}

  303.         }, { // High offset

  304.             {256,  58, 256},

  305.             {256, 245, 256},

  306.             {256, 238, 256},

  307.             {256, 232, 256},

  308.             {256, 225, 256},

  309.             {256, 220, 256},

  310.             {256, 211, 256}

  311.         }

  312.     }, { // Unvoiced

  313.         {    // Low offset

  314.             {256,   1, 256},

  315.             {256, 210, 256},

  316.             {256, 190, 256},

  317.             {256, 178, 256},

  318.             {256, 169, 256},

  319.             {256, 162, 256},

  320.             {256, 152, 256}

  321.         }, { // High offset

  322.             {256,  48, 256},

  323.             {256, 242, 256},

  324.             {256, 235, 256},

  325.             {256, 224, 256},

  326.             {256, 214, 256},

  327.             {256, 205, 256},

  328.             {256, 190, 256}

  329.         }

  330.     }, { // Voiced

  331.         {    // Low offset

  332.             {256,   1, 256},

  333.             {256, 162, 256},

  334.             {256, 152, 256},

  335.             {256, 147, 256},

  336.             {256, 144, 256},

  337.             {256, 141, 256},

  338.             {256, 138, 256}

  339.         }, { // High offset

  340.             {256,   8, 256},

  341.             {256, 203, 256},

  342.             {256, 187, 256},

  343.             {256, 176, 256},

  344.             {256, 168, 256},

  345.             {256, 161, 256},

  346.             {256, 154, 256}

  347.         }

  348.     }

  349. };

  350. 

  351. static const int16_t silk_stereo_weights[] = {

  352.     -13732, -10050,  -8266,  -7526,  -6500,  -5000,  -2950,   -820,

  353.        820,   2950,   5000,   6500,   7526,   8266,  10050,  13732

  354. };

  355. 

  356. static const uint8_t silk_lsf_s2_model_sel_nbmb[32][10] = {

  357.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  358.     { 1, 3, 1, 2, 2, 1, 2, 1, 1, 1 },

  359.     { 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 },

  360.     { 1, 2, 2, 2, 2, 1, 2, 1, 1, 1 },

  361.     { 2, 3, 3, 3, 3, 2, 2, 2, 2, 2 },

  362.     { 0, 5, 3, 3, 2, 2, 2, 2, 1, 1 },

  363.     { 0, 2, 2, 2, 2, 2, 2, 2, 2, 1 },

  364.     { 2, 3, 6, 4, 4, 4, 5, 4, 5, 5 },

  365.     { 2, 4, 5, 5, 4, 5, 4, 6, 4, 4 },

  366.     { 2, 4, 4, 7, 4, 5, 4, 5, 5, 4 },

  367.     { 4, 3, 3, 3, 2, 3, 2, 2, 2, 2 },

  368.     { 1, 5, 5, 6, 4, 5, 4, 5, 5, 5 },

  369.     { 2, 7, 4, 6, 5, 5, 5, 5, 5, 5 },

  370.     { 2, 7, 5, 5, 5, 5, 5, 6, 5, 4 },

  371.     { 3, 3, 5, 4, 4, 5, 4, 5, 4, 4 },

  372.     { 2, 3, 3, 5, 5, 4, 4, 4, 4, 4 },

  373.     { 2, 4, 4, 6, 4, 5, 4, 5, 5, 5 },

  374.     { 2, 5, 4, 6, 5, 5, 5, 4, 5, 4 },

  375.     { 2, 7, 4, 5, 4, 5, 4, 5, 5, 5 },

  376.     { 2, 5, 4, 6, 7, 6, 5, 6, 5, 4 },

  377.     { 3, 6, 7, 4, 6, 5, 5, 6, 4, 5 },

  378.     { 2, 7, 6, 4, 4, 4, 5, 4, 5, 5 },

  379.     { 4, 5, 5, 4, 6, 6, 5, 6, 5, 4 },

  380.     { 2, 5, 5, 6, 5, 6, 4, 6, 4, 4 },

  381.     { 4, 5, 5, 5, 3, 7, 4, 5, 5, 4 },

  382.     { 2, 3, 4, 5, 5, 6, 4, 5, 5, 4 },

  383.     { 2, 3, 2, 3, 3, 4, 2, 3, 3, 3 },

  384.     { 1, 1, 2, 2, 2, 2, 2, 3, 2, 2 },

  385.     { 4, 5, 5, 6, 6, 6, 5, 6, 4, 5 },

  386.     { 3, 5, 5, 4, 4, 4, 4, 3, 3, 2 },

  387.     { 2, 5, 3, 7, 5, 5, 4, 4, 5, 4 },

  388.     { 4, 4, 5, 4, 5, 6, 5, 6, 5, 4 }

  389. };

  390. 

  391. static const uint8_t silk_lsf_s2_model_sel_wb[32][16] = {

  392.     {  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },

  393.     { 10, 11, 11, 11, 11, 11, 10, 10, 10, 10, 10,  9,  9,  9,  8, 11 },

  394.     { 10, 13, 13, 11, 15, 12, 12, 13, 10, 13, 12, 13, 13, 12, 11, 11 },

  395.     {  8, 10,  9, 10, 10,  9,  9,  9,  9,  9,  8,  8,  8,  8,  8,  9 },

  396.     {  8, 14, 13, 12, 14, 12, 15, 13, 12, 12, 12, 13, 13, 12, 12, 11 },

  397.     {  8, 11, 13, 13, 12, 11, 11, 13, 11, 11, 11, 11, 11, 11, 10, 12 },

  398.     {  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },

  399.     {  8, 10, 14, 11, 15, 10, 13, 11, 12, 13, 13, 12, 11, 11, 10, 11 },

  400.     {  8, 14, 10, 14, 14, 12, 13, 12, 14, 13, 12, 12, 13, 11, 11, 11 },

  401.     { 10,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },

  402.     {  8,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9 },

  403.     { 10, 10, 11, 12, 13, 11, 11, 11, 11, 11, 11, 11, 10, 10,  9, 11 },

  404.     { 10, 10, 11, 11, 12, 11, 11, 11, 11, 11, 11, 11, 11, 10,  9, 11 },

  405.     { 11, 12, 12, 12, 14, 12, 12, 13, 11, 13, 12, 12, 13, 12, 11, 12 },

  406.     {  8, 14, 12, 13, 12, 15, 13, 10, 14, 13, 15, 12, 12, 11, 13, 11 },

  407.     {  8,  9,  8,  9,  9,  9,  9,  9,  9,  9,  8,  8,  8,  8,  9,  8 },

  408.     {  9, 14, 13, 15, 13, 12, 13, 11, 12, 13, 12, 12, 12, 11, 11, 12 },

  409.     {  9, 11, 11, 12, 12, 11, 11, 13, 10, 11, 11, 13, 13, 13, 11, 12 },

  410.     { 10, 11, 11, 10, 10, 10, 11, 10,  9, 10,  9, 10,  9,  9,  9, 12 },

  411.     {  8, 10, 11, 13, 11, 11, 10, 10, 10,  9,  9,  8,  8,  8,  8,  8 },

  412.     { 11, 12, 11, 13, 11, 11, 10, 10,  9,  9,  9,  9,  9, 10, 10, 12 },

  413.     { 10, 14, 11, 15, 15, 12, 13, 12, 13, 11, 13, 11, 11, 10, 11, 11 },

  414.     { 10, 11, 13, 14, 14, 11, 13, 11, 12, 12, 11, 11, 11, 11, 10, 12 },

  415.     {  9, 11, 11, 12, 12, 12, 12, 11, 13, 13, 13, 11,  9,  9,  9,  9 },

  416.     { 10, 13, 11, 14, 14, 12, 15, 12, 12, 13, 11, 12, 12, 11, 11, 11 },

  417.     {  8, 14,  9,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },

  418.     {  8, 14, 14, 11, 13, 10, 13, 13, 11, 12, 12, 15, 15, 12, 12, 12 },

  419.     { 11, 11, 15, 11, 13, 12, 11, 11, 11, 10, 10, 11, 11, 11, 10, 11 },

  420.     {  8,  8,  9,  8,  8,  8, 10,  9, 10,  9,  9, 10, 10, 10,  9,  9 },

  421.     {  8, 11, 10, 13, 11, 11, 10, 11, 10,  9,  8,  8,  9,  8,  8,  9 },

  422.     { 11, 13, 13, 12, 15, 13, 11, 11, 10, 11, 10, 10,  9,  8,  9,  8 },

  423.     { 10, 11, 13, 11, 12, 11, 11, 11, 10,  9, 10, 14, 12,  8,  8,  8 }

  424. };

  425. 

  426. static const uint8_t silk_lsf_pred_weights_nbmb[2][9] = {

  427.     {179, 138, 140, 148, 151, 149, 153, 151, 163},

  428.     {116,  67,  82,  59,  92,  72, 100,  89,  92}

  429. };

  430. 

  431. static const uint8_t silk_lsf_pred_weights_wb[2][15] = {

  432.     {175, 148, 160, 176, 178, 173, 174, 164, 177, 174, 196, 182, 198, 192, 182},

  433.     { 68,  62,  66,  60,  72, 117,  85,  90, 118, 136, 151, 142, 160, 142, 155}

  434. };

  435. 

  436. static const uint8_t silk_lsf_weight_sel_nbmb[32][9] = {

  437.     { 0, 1, 0, 0, 0, 0, 0, 0, 0 },

  438.     { 1, 0, 0, 0, 0, 0, 0, 0, 0 },

  439.     { 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  440.     { 1, 1, 1, 0, 0, 0, 0, 1, 0 },

  441.     { 0, 1, 0, 0, 0, 0, 0, 0, 0 },

  442.     { 0, 1, 0, 0, 0, 0, 0, 0, 0 },

  443.     { 1, 0, 1, 1, 0, 0, 0, 1, 0 },

  444.     { 0, 1, 1, 0, 0, 1, 1, 0, 0 },

  445.     { 0, 0, 1, 1, 0, 1, 0, 1, 1 },

  446.     { 0, 0, 1, 1, 0, 0, 1, 1, 1 },

  447.     { 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  448.     { 0, 1, 0, 1, 1, 1, 1, 1, 0 },

  449.     { 0, 1, 0, 1, 1, 1, 1, 1, 0 },

  450.     { 0, 1, 1, 1, 1, 1, 1, 1, 0 },

  451.     { 1, 0, 1, 1, 0, 1, 1, 1, 1 },

  452.     { 0, 1, 1, 1, 1, 1, 0, 1, 0 },

  453.     { 0, 0, 1, 1, 0, 1, 0, 1, 0 },

  454.     { 0, 0, 1, 1, 1, 0, 1, 1, 1 },

  455.     { 0, 1, 1, 0, 0, 1, 1, 1, 0 },

  456.     { 0, 0, 0, 1, 1, 1, 0, 1, 0 },

  457.     { 0, 1, 1, 0, 0, 1, 0, 1, 0 },

  458.     { 0, 1, 1, 0, 0, 0, 1, 1, 0 },

  459.     { 0, 0, 0, 0, 0, 1, 1, 1, 1 },

  460.     { 0, 0, 1, 1, 0, 0, 0, 1, 1 },

  461.     { 0, 0, 0, 1, 0, 1, 1, 1, 1 },

  462.     { 0, 1, 1, 1, 1, 1, 1, 1, 0 },

  463.     { 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  464.     { 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  465.     { 0, 0, 1, 0, 1, 1, 0, 1, 0 },

  466.     { 1, 0, 0, 1, 0, 0, 0, 0, 0 },

  467.     { 0, 0, 0, 1, 1, 0, 1, 0, 1 },

  468.     { 1, 0, 1, 1, 0, 1, 1, 1, 1 }

  469. };

  470. 

  471. static const uint8_t silk_lsf_weight_sel_wb[32][15] = {

  472.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },

  473.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  474.     { 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },

  475.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },

  476.     { 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0 },

  477.     { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  478.     { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 },

  479.     { 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1 },

  480.     { 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1 },

  481.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },

  482.     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  483.     { 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0 },

  484.     { 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0 },

  485.     { 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0 },

  486.     { 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 },

  487.     { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0 },

  488.     { 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0 },

  489.     { 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0 },

  490.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },

  491.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },

  492.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

  493.     { 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0 },

  494.     { 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0 },

  495.     { 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0 },

  496.     { 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1 },

  497.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },

  498.     { 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1 },

  499.     { 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },

  500.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },

  501.     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },

  502.     { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },

  503.     { 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0 }

  504. };

  505. 

  506. static const uint8_t silk_lsf_codebook_nbmb[32][10] = {

  507.     { 12,  35,  60,  83, 108, 132, 157, 180, 206, 228 },

  508.     { 15,  32,  55,  77, 101, 125, 151, 175, 201, 225 },

  509.     { 19,  42,  66,  89, 114, 137, 162, 184, 209, 230 },

  510.     { 12,  25,  50,  72,  97, 120, 147, 172, 200, 223 },

  511.     { 26,  44,  69,  90, 114, 135, 159, 180, 205, 225 },

  512.     { 13,  22,  53,  80, 106, 130, 156, 180, 205, 228 },

  513.     { 15,  25,  44,  64,  90, 115, 142, 168, 196, 222 },

  514.     { 19,  24,  62,  82, 100, 120, 145, 168, 190, 214 },

  515.     { 22,  31,  50,  79, 103, 120, 151, 170, 203, 227 },

  516.     { 21,  29,  45,  65, 106, 124, 150, 171, 196, 224 },

  517.     { 30,  49,  75,  97, 121, 142, 165, 186, 209, 229 },

  518.     { 19,  25,  52,  70,  93, 116, 143, 166, 192, 219 },

  519.     { 26,  34,  62,  75,  97, 118, 145, 167, 194, 217 },

  520.     { 25,  33,  56,  70,  91, 113, 143, 165, 196, 223 },

  521.     { 21,  34,  51,  72,  97, 117, 145, 171, 196, 222 },

  522.     { 20,  29,  50,  67,  90, 117, 144, 168, 197, 221 },

  523.     { 22,  31,  48,  66,  95, 117, 146, 168, 196, 222 },

  524.     { 24,  33,  51,  77, 116, 134, 158, 180, 200, 224 },

  525.     { 21,  28,  70,  87, 106, 124, 149, 170, 194, 217 },

  526.     { 26,  33,  53,  64,  83, 117, 152, 173, 204, 225 },

  527.     { 27,  34,  65,  95, 108, 129, 155, 174, 210, 225 },

  528.     { 20,  26,  72,  99, 113, 131, 154, 176, 200, 219 },

  529.     { 34,  43,  61,  78,  93, 114, 155, 177, 205, 229 },

  530.     { 23,  29,  54,  97, 124, 138, 163, 179, 209, 229 },

  531.     { 30,  38,  56,  89, 118, 129, 158, 178, 200, 231 },

  532.     { 21,  29,  49,  63,  85, 111, 142, 163, 193, 222 },

  533.     { 27,  48,  77, 103, 133, 158, 179, 196, 215, 232 },

  534.     { 29,  47,  74,  99, 124, 151, 176, 198, 220, 237 },

  535.     { 33,  42,  61,  76,  93, 121, 155, 174, 207, 225 },

  536.     { 29,  53,  87, 112, 136, 154, 170, 188, 208, 227 },

  537.     { 24,  30,  52,  84, 131, 150, 166, 186, 203, 229 },

  538.     { 37,  48,  64,  84, 104, 118, 156, 177, 201, 230 }

  539. };

  540. 

  541. static const uint8_t silk_lsf_codebook_wb[32][16] = {

  542.     {  7,  23,  38,  54,  69,  85, 100, 116, 131, 147, 162, 178, 193, 208, 223, 239 },

  543.     { 13,  25,  41,  55,  69,  83,  98, 112, 127, 142, 157, 171, 187, 203, 220, 236 },

  544.     { 15,  21,  34,  51,  61,  78,  92, 106, 126, 136, 152, 167, 185, 205, 225, 240 },

  545.     { 10,  21,  36,  50,  63,  79,  95, 110, 126, 141, 157, 173, 189, 205, 221, 237 },

  546.     { 17,  20,  37,  51,  59,  78,  89, 107, 123, 134, 150, 164, 184, 205, 224, 240 },

  547.     { 10,  15,  32,  51,  67,  81,  96, 112, 129, 142, 158, 173, 189, 204, 220, 236 },

  548.     {  8,  21,  37,  51,  65,  79,  98, 113, 126, 138, 155, 168, 179, 192, 209, 218 },

  549.     { 12,  15,  34,  55,  63,  78,  87, 108, 118, 131, 148, 167, 185, 203, 219, 236 },

  550.     { 16,  19,  32,  36,  56,  79,  91, 108, 118, 136, 154, 171, 186, 204, 220, 237 },

  551.     { 11,  28,  43,  58,  74,  89, 105, 120, 135, 150, 165, 180, 196, 211, 226, 241 },

  552.     {  6,  16,  33,  46,  60,  75,  92, 107, 123, 137, 156, 169, 185, 199, 214, 225 },

  553.     { 11,  19,  30,  44,  57,  74,  89, 105, 121, 135, 152, 169, 186, 202, 218, 234 },

  554.     { 12,  19,  29,  46,  57,  71,  88, 100, 120, 132, 148, 165, 182, 199, 216, 233 },

  555.     { 17,  23,  35,  46,  56,  77,  92, 106, 123, 134, 152, 167, 185, 204, 222, 237 },

  556.     { 14,  17,  45,  53,  63,  75,  89, 107, 115, 132, 151, 171, 188, 206, 221, 240 },

  557.     {  9,  16,  29,  40,  56,  71,  88, 103, 119, 137, 154, 171, 189, 205, 222, 237 },

  558.     { 16,  19,  36,  48,  57,  76,  87, 105, 118, 132, 150, 167, 185, 202, 218, 236 },

  559.     { 12,  17,  29,  54,  71,  81,  94, 104, 126, 136, 149, 164, 182, 201, 221, 237 },

  560.     { 15,  28,  47,  62,  79,  97, 115, 129, 142, 155, 168, 180, 194, 208, 223, 238 },

  561.     {  8,  14,  30,  45,  62,  78,  94, 111, 127, 143, 159, 175, 192, 207, 223, 239 },

  562.     { 17,  30,  49,  62,  79,  92, 107, 119, 132, 145, 160, 174, 190, 204, 220, 235 },

  563.     { 14,  19,  36,  45,  61,  76,  91, 108, 121, 138, 154, 172, 189, 205, 222, 238 },

  564.     { 12,  18,  31,  45,  60,  76,  91, 107, 123, 138, 154, 171, 187, 204, 221, 236 },

  565.     { 13,  17,  31,  43,  53,  70,  83, 103, 114, 131, 149, 167, 185, 203, 220, 237 },

  566.     { 17,  22,  35,  42,  58,  78,  93, 110, 125, 139, 155, 170, 188, 206, 224, 240 },

  567.     {  8,  15,  34,  50,  67,  83,  99, 115, 131, 146, 162, 178, 193, 209, 224, 239 },

  568.     { 13,  16,  41,  66,  73,  86,  95, 111, 128, 137, 150, 163, 183, 206, 225, 241 },

  569.     { 17,  25,  37,  52,  63,  75,  92, 102, 119, 132, 144, 160, 175, 191, 212, 231 },

  570.     { 19,  31,  49,  65,  83, 100, 117, 133, 147, 161, 174, 187, 200, 213, 227, 242 },

  571.     { 18,  31,  52,  68,  88, 103, 117, 126, 138, 149, 163, 177, 192, 207, 223, 239 },

  572.     { 16,  29,  47,  61,  76,  90, 106, 119, 133, 147, 161, 176, 193, 209, 224, 240 },

  573.     { 15,  21,  35,  50,  61,  73,  86,  97, 110, 119, 129, 141, 175, 198, 218, 237 }

  574. };

  575. 

  576. static const uint16_t silk_lsf_min_spacing_nbmb[] = {

  577.     250, 3, 6, 3, 3, 3, 4, 3, 3, 3, 461

  578. };

  579. 

  580. static const uint16_t silk_lsf_min_spacing_wb[] = {

  581.     100, 3, 40, 3, 3, 3, 5, 14, 14, 10, 11, 3, 8, 9, 7, 3, 347

  582. };

  583. 

  584. static const uint8_t silk_lsf_ordering_nbmb[] = {

  585.     0, 9, 6, 3, 4, 5, 8, 1, 2, 7

  586. };

  587. 

  588. static const uint8_t silk_lsf_ordering_wb[] = {

  589.     0, 15, 8, 7, 4, 11, 12, 3, 2, 13, 10, 5, 6, 9, 14, 1

  590. };

  591. 

  592. static const int16_t silk_cosine[] = { /* (0.12) */

  593.      4096,  4095,  4091,  4085,

  594.      4076,  4065,  4052,  4036,

  595.      4017,  3997,  3973,  3948,

  596.      3920,  3889,  3857,  3822,

  597.      3784,  3745,  3703,  3659,

  598.      3613,  3564,  3513,  3461,

  599.      3406,  3349,  3290,  3229,

  600.      3166,  3102,  3035,  2967,

  601.      2896,  2824,  2751,  2676,

  602.      2599,  2520,  2440,  2359,

  603.      2276,  2191,  2106,  2019,

  604.      1931,  1842,  1751,  1660,

  605.      1568,  1474,  1380,  1285,

  606.      1189,  1093,   995,   897,

  607.       799,   700,   601,   501,

  608.       401,   301,   201,   101,

  609.         0,  -101,  -201,  -301,

  610.      -401,  -501,  -601,  -700,

  611.      -799,  -897,  -995, -1093,

  612.     -1189, -1285, -1380, -1474,

  613.     -1568, -1660, -1751, -1842,

  614.     -1931, -2019, -2106, -2191,

  615.     -2276, -2359, -2440, -2520,

  616.     -2599, -2676, -2751, -2824,

  617.     -2896, -2967, -3035, -3102,

  618.     -3166, -3229, -3290, -3349,

  619.     -3406, -3461, -3513, -3564,

  620.     -3613, -3659, -3703, -3745,

  621.     -3784, -3822, -3857, -3889,

  622.     -3920, -3948, -3973, -3997,

  623.     -4017, -4036, -4052, -4065,

  624.     -4076, -4085, -4091, -4095,

  625.     -4096

  626. };

  627. 

  628. static const uint16_t silk_pitch_scale[]   = {  4,   6,   8};

  629. 

  630. static const uint16_t silk_pitch_min_lag[] = { 16,  24,  32};

  631. 

  632. static const uint16_t silk_pitch_max_lag[] = {144, 216, 288};

  633. 

  634. static const int8_t silk_pitch_offset_nb10ms[3][2] = {

  635.     { 0,  0},

  636.     { 1,  0},

  637.     { 0,  1}

  638. };

  639. 

  640. static const int8_t silk_pitch_offset_nb20ms[11][4] = {

  641.     { 0,  0,  0,  0},

  642.     { 2,  1,  0, -1},

  643.     {-1,  0,  1,  2},

  644.     {-1,  0,  0,  1},

  645.     {-1,  0,  0,  0},

  646.     { 0,  0,  0,  1},

  647.     { 0,  0,  1,  1},

  648.     { 1,  1,  0,  0},

  649.     { 1,  0,  0,  0},

  650.     { 0,  0,  0, -1},

  651.     { 1,  0,  0, -1}

  652. };

  653. 

  654. static const int8_t silk_pitch_offset_mbwb10ms[12][2] = {

  655.     { 0,  0},

  656.     { 0,  1},

  657.     { 1,  0},

  658.     {-1,  1},

  659.     { 1, -1},

  660.     {-1,  2},

  661.     { 2, -1},

  662.     {-2,  2},

  663.     { 2, -2},

  664.     {-2,  3},

  665.     { 3, -2},

  666.     {-3,  3}

  667. };

  668. 

  669. static const int8_t silk_pitch_offset_mbwb20ms[34][4] = {

  670.     { 0,  0,  0,  0},

  671.     { 0,  0,  1,  1},

  672.     { 1,  1,  0,  0},

  673.     {-1,  0,  0,  0},

  674.     { 0,  0,  0,  1},

  675.     { 1,  0,  0,  0},

  676.     {-1,  0,  0,  1},

  677.     { 0,  0,  0, -1},

  678.     {-1,  0,  1,  2},

  679.     { 1,  0,  0, -1},

  680.     {-2, -1,  1,  2},

  681.     { 2,  1,  0, -1},

  682.     {-2,  0,  0,  2},

  683.     {-2,  0,  1,  3},

  684.     { 2,  1, -1, -2},

  685.     {-3, -1,  1,  3},

  686.     { 2,  0,  0, -2},

  687.     { 3,  1,  0, -2},

  688.     {-3, -1,  2,  4},

  689.     {-4, -1,  1,  4},

  690.     { 3,  1, -1, -3},

  691.     {-4, -1,  2,  5},

  692.     { 4,  2, -1, -3},

  693.     { 4,  1, -1, -4},

  694.     {-5, -1,  2,  6},

  695.     { 5,  2, -1, -4},

  696.     {-6, -2,  2,  6},

  697.     {-5, -2,  2,  5},

  698.     { 6,  2, -1, -5},

  699.     {-7, -2,  3,  8},

  700.     { 6,  2, -2, -6},

  701.     { 5,  2, -2, -5},

  702.     { 8,  3, -2, -7},

  703.     {-9, -3,  3,  9}

  704. };

  705. 

  706. static const int8_t silk_ltp_filter0_taps[8][5] = {

  707.     {  4,   6,  24,   7,   5},

  708.     {  0,   0,   2,   0,   0},

  709.     { 12,  28,  41,  13,  -4},

  710.     { -9,  15,  42,  25,  14},

  711.     {  1,  -2,  62,  41,  -9},

  712.     {-10,  37,  65,  -4,   3},

  713.     { -6,   4,  66,   7,  -8},

  714.     { 16,  14,  38,  -3,  33}

  715. };

  716. 

  717. static const int8_t silk_ltp_filter1_taps[16][5] = {

  718.     { 13,  22,  39,  23,  12},

  719.     { -1,  36,  64,  27,  -6},

  720.     { -7,  10,  55,  43,  17},

  721.     {  1,   1,   8,   1,   1},

  722.     {  6, -11,  74,  53,  -9},

  723.     {-12,  55,  76, -12,   8},

  724.     { -3,   3,  93,  27,  -4},

  725.     { 26,  39,  59,   3,  -8},

  726.     {  2,   0,  77,  11,   9},

  727.     { -8,  22,  44,  -6,   7},

  728.     { 40,   9,  26,   3,   9},

  729.     { -7,  20, 101,  -7,   4},

  730.     {  3,  -8,  42,  26,   0},

  731.     {-15,  33,  68,   2,  23},

  732.     { -2,  55,  46,  -2,  15},

  733.     {  3,  -1,  21,  16,  41}

  734. };

  735. 

  736. static const int8_t silk_ltp_filter2_taps[32][5] = {

  737.     { -6,  27,  61,  39,   5},

  738.     {-11,  42,  88,   4,   1},

  739.     { -2,  60,  65,   6,  -4},

  740.     { -1,  -5,  73,  56,   1},

  741.     { -9,  19,  94,  29,  -9},

  742.     {  0,  12,  99,   6,   4},

  743.     {  8, -19, 102,  46, -13},

  744.     {  3,   2,  13,   3,   2},

  745.     {  9, -21,  84,  72, -18},

  746.     {-11,  46, 104, -22,   8},

  747.     { 18,  38,  48,  23,   0},

  748.     {-16,  70,  83, -21,  11},

  749.     {  5, -11, 117,  22,  -8},

  750.     { -6,  23, 117, -12,   3},

  751.     {  3,  -8,  95,  28,   4},

  752.     {-10,  15,  77,  60, -15},

  753.     { -1,   4, 124,   2,  -4},

  754.     {  3,  38,  84,  24, -25},

  755.     {  2,  13,  42,  13,  31},

  756.     { 21,  -4,  56,  46,  -1},

  757.     { -1,  35,  79, -13,  19},

  758.     { -7,  65,  88,  -9, -14},

  759.     { 20,   4,  81,  49, -29},

  760.     { 20,   0,  75,   3, -17},

  761.     {  5,  -9,  44,  92,  -8},

  762.     {  1,  -3,  22,  69,  31},

  763.     { -6,  95,  41, -12,   5},

  764.     { 39,  67,  16,  -4,   1},

  765.     {  0,  -6, 120,  55, -36},

  766.     {-13,  44, 122,   4, -24},

  767.     { 81,   5,  11,   3,   7},

  768.     {  2,   0,   9,  10,  88}

  769. };

  770. 

  771. static const uint16_t silk_ltp_scale_factor[] = {15565, 12288, 8192};

  772. 

  773. static const uint8_t silk_shell_blocks[3][2] = {

  774.     { 5, 10}, // NB

  775.     { 8, 15}, // MB

  776.     {10, 20}  // WB

  777. };

  778. 

  779. static const uint8_t silk_quant_offset[2][2] = { /* (0.23) */

  780.     {25, 60}, // Inactive or Unvoiced

  781.     { 8, 25}  // Voiced

  782. };

  783. 

  784. static const int silk_stereo_interp_len[3] = {

  785.     64, 96, 128

  786. };

  787. 

  788. static inline void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_t min_delta[17])

  789. {

  790.     int pass, i;

  791.     for (pass = 0; pass < 20; pass++) {

  792.         int k, min_diff = 0;

  793.         for (i = 0; i < order+1; i++) {

  794.             int low  = i != 0     ? nlsf[i-1] : 0;

  795.             int high = i != order ? nlsf[i]   : 32768;

  796.             int diff = (high - low) - (min_delta[i]);

  797. 

  798.             if (diff < min_diff) {

  799.                 min_diff = diff;

  800.                 k = i;

  801. 

  802.                 if (pass == 20)

  803.                     break;

  804.             }

  805.         }

  806.         if (min_diff == 0) /* no issues; stabilized */

  807.             return;

  808. 

  809.         /* wiggle one or two LSFs */

  810.         if (k == 0) {

  811.             /* repel away from lower bound */

  812.             nlsf[0] = min_delta[0];

  813.         } else if (k == order) {

  814.             /* repel away from higher bound */

  815.             nlsf[order-1] = 32768 - min_delta[order];

  816.         } else {

  817.             /* repel away from current position */

  818.             int min_center = 0, max_center = 32768, center_val;

  819. 

  820.             /* lower extent */

  821.             for (i = 0; i < k; i++)

  822.                 min_center += min_delta[i];

  823.             min_center += min_delta[k] >> 1;

  824. 

  825.             /* upper extent */

  826.             for (i = order; i > k; i--)

  827.                 max_center -= min_delta[i];

  828.             max_center -= min_delta[k] >> 1;

  829. 

  830.             /* move apart */

  831.             center_val = nlsf[k - 1] + nlsf[k];

  832.             center_val = (center_val >> 1) + (center_val & 1); // rounded divide by 2

  833.             center_val = FFMIN(max_center, FFMAX(min_center, center_val));

  834. 

  835.             nlsf[k - 1] = center_val - (min_delta[k] >> 1);

  836.             nlsf[k]     = nlsf[k - 1] + min_delta[k];

  837.         }

  838.     }

  839. 

  840.     /* resort to the fall-back method, the standard method for LSF stabilization */

  841. 

  842.     /* sort; as the LSFs should be nearly sorted, use insertion sort */

  843.     for (i = 1; i < order; i++) {

  844.         int j, value = nlsf[i];

  845.         for (j = i - 1; j >= 0 && nlsf[j] > value; j--)

  846.             nlsf[j + 1] = nlsf[j];

  847.         nlsf[j + 1] = value;

  848.     }

  849. 

  850.     /* push forwards to increase distance */

  851.     if (nlsf[0] < min_delta[0])

  852.         nlsf[0] = min_delta[0];

  853.     for (i = 1; i < order; i++)

  854.         if (nlsf[i] < nlsf[i - 1] + min_delta[i])

  855.             nlsf[i] = nlsf[i - 1] + min_delta[i];

  856. 

  857.     /* push backwards to increase distance */

  858.     if (nlsf[order-1] > 32768 - min_delta[order])

  859.         nlsf[order-1] = 32768 - min_delta[order];

  860.     for (i = order-2; i >= 0; i--)

  861.         if (nlsf[i] > nlsf[i + 1] - min_delta[i+1])

  862.             nlsf[i] = nlsf[i + 1] - min_delta[i+1];

  863. 

  864.     return;

  865. }

  866. 

  867. static inline int silk_is_lpc_stable(const int16_t lpc[16], int order)

  868. {

  869.     int k, j, DC_resp = 0;

  870.     int32_t lpc32[2][16];       // Q24

  871.     int totalinvgain = 1 << 30; // 1.0 in Q30

  872.     int32_t *row = lpc32[0], *prevrow;

  873. 

  874.     /* initialize the first row for the Levinson recursion */

  875.     for (k = 0; k < order; k++) {

  876.         DC_resp += lpc[k];

  877.         row[k] = lpc[k] * 4096;

  878.     }

  879. 

  880.     if (DC_resp >= 4096)

  881.         return 0;

  882. 

  883.     /* check if prediction gain pushes any coefficients too far */

  884.     for (k = order - 1; 1; k--) {

  885.         int rc;      // Q31; reflection coefficient

  886.         int gaindiv; // Q30; inverse of the gain (the divisor)

  887.         int gain;    // gain for this reflection coefficient

  888.         int fbits;   // fractional bits used for the gain

  889.         int error;   // Q29; estimate of the error of our partial estimate of 1/gaindiv

  890. 

  891.         if (FFABS(row[k]) > 16773022)

  892.             return 0;

  893. 

  894.         rc      = -(row[k] * 128);

  895.         gaindiv = (1 << 30) - MULH(rc, rc);

  896. 

  897.         totalinvgain = MULH(totalinvgain, gaindiv) << 2;

  898.         if (k == 0)

  899.             return (totalinvgain >= 107374);

  900. 

  901.         /* approximate 1.0/gaindiv */

  902.         fbits = opus_ilog(gaindiv);

  903.         gain  = ((1 << 29) - 1) / (gaindiv >> (fbits + 1 - 16)); // Q<fbits-16>

  904.         error = (1 << 29) - MULL(gaindiv << (15 + 16 - fbits), gain, 16);

  905.         gain  = ((gain << 16) + (error * gain >> 13));

  906. 

  907.         /* switch to the next row of the LPC coefficients */

  908.         prevrow = row;

  909.         row = lpc32[k & 1];

  910. 

  911.         for (j = 0; j < k; j++) {

  912.             int x = prevrow[j] - ROUND_MULL(prevrow[k - j - 1], rc, 31);

  913.             row[j] = ROUND_MULL(x, gain, fbits);

  914.         }

  915.     }

  916. }

  917. 

  918. static void silk_lsp2poly(const int32_t lsp[16], int32_t pol[16], int half_order)

  919. {

  920.     int i, j;

  921. 

  922.     pol[0] = 65536; // 1.0 in Q16

  923.     pol[1] = -lsp[0];

  924. 

  925.     for (i = 1; i < half_order; i++) {

  926.         pol[i + 1] = pol[i - 1] * 2 - ROUND_MULL(lsp[2 * i], pol[i], 16);

  927.         for (j = i; j > 1; j--)

  928.             pol[j] += pol[j - 2] - ROUND_MULL(lsp[2 * i], pol[j - 1], 16);

  929. 

  930.         pol[1] -= lsp[2 * i];

  931.     }

  932. }

  933. 

  934. static void silk_lsf2lpc(const int16_t nlsf[16], float lpcf[16], int order)

  935. {

  936.     int i, k;

  937.     int32_t lsp[16];     // Q17; 2*cos(LSF)

  938.     int32_t p[9], q[9];  // Q16

  939.     int32_t lpc32[16];   // Q17

  940.     int16_t lpc[16];     // Q12

  941. 

  942.     /* convert the LSFs to LSPs, i.e. 2*cos(LSF) */

  943.     for (k = 0; k < order; k++) {

  944.         int index = nlsf[k] >> 8;

  945.         int offset = nlsf[k] & 255;

  946.         int k2 = (order == 10) ? silk_lsf_ordering_nbmb[k] : silk_lsf_ordering_wb[k];

  947. 

  948.         /* interpolate and round */

  949.         lsp[k2]  = silk_cosine[index] * 256;

  950.         lsp[k2] += (silk_cosine[index + 1] - silk_cosine[index]) * offset;

  951.         lsp[k2]  = (lsp[k2] + 4) >> 3;

  952.     }

  953. 

  954.     silk_lsp2poly(lsp    , p, order >> 1);

  955.     silk_lsp2poly(lsp + 1, q, order >> 1);

  956. 

  957.     /* reconstruct A(z) */

  958.     for (k = 0; k < order>>1; k++) {

  959.         lpc32[k]         = -p[k + 1] - p[k] - q[k + 1] + q[k];

  960.         lpc32[order-k-1] = -p[k + 1] - p[k] + q[k + 1] - q[k];

  961.     }

  962. 

  963.     /* limit the range of the LPC coefficients to each fit within an int16_t */

  964.     for (i = 0; i < 10; i++) {

  965.         int j;

  966.         unsigned int maxabs = 0;

  967.         for (j = 0, k = 0; j < order; j++) {

  968.             unsigned int x = FFABS(lpc32[k]);

  969.             if (x > maxabs) {

  970.                 maxabs = x; // Q17

  971.                 k      = j;

  972.             }

  973.         }

  974. 

  975.         maxabs = (maxabs + 16) >> 5; // convert to Q12

  976. 

  977.         if (maxabs > 32767) {

  978.             /* perform bandwidth expansion */

  979.             unsigned int chirp, chirp_base; // Q16

  980.             maxabs = FFMIN(maxabs, 163838); // anything above this overflows chirp's numerator

  981.             chirp_base = chirp = 65470 - ((maxabs - 32767) << 14) / ((maxabs * (k+1)) >> 2);

  982. 

  983.             for (k = 0; k < order; k++) {

  984.                 lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);

  985.                 chirp    = (chirp_base * chirp + 32768) >> 16;

  986.             }

  987.         } else break;

  988.     }

  989. 

  990.     if (i == 10) {

  991.         /* time's up: just clamp */

  992.         for (k = 0; k < order; k++) {

  993.             int x = (lpc32[k] + 16) >> 5;

  994.             lpc[k] = av_clip_int16(x);

  995.             lpc32[k] = lpc[k] << 5; // shortcut mandated by the spec; drops lower 5 bits

  996.         }

  997.     } else {

  998.         for (k = 0; k < order; k++)

  999.             lpc[k] = (lpc32[k] + 16) >> 5;

  1000.     }

  1001. 

  1002.     /* if the prediction gain causes the LPC filter to become unstable,

  1003.        apply further bandwidth expansion on the Q17 coefficients */

  1004.     for (i = 1; i <= 16 && !silk_is_lpc_stable(lpc, order); i++) {

  1005.         unsigned int chirp, chirp_base;

  1006.         chirp_base = chirp = 65536 - (1 << i);

  1007. 

  1008.         for (k = 0; k < order; k++) {

  1009.             lpc32[k] = ROUND_MULL(lpc32[k], chirp, 16);

  1010.             lpc[k]   = (lpc32[k] + 16) >> 5;

  1011.             chirp    = (chirp_base * chirp + 32768) >> 16;

  1012.         }

  1013.     }

  1014. 

  1015.     for (i = 0; i < order; i++)

  1016.         lpcf[i] = lpc[i] / 4096.0f;

  1017. }

  1018. 

  1019. static inline void silk_decode_lpc(SilkContext *s, SilkFrame *frame,

  1020.                                    OpusRangeCoder *rc,

  1021.                                    float lpc_leadin[16], float lpc[16],

  1022.                                    int *lpc_order, int *has_lpc_leadin, int voiced)

  1023. {

  1024.     int i;

  1025.     int order;                   // order of the LP polynomial; 10 for NB/MB and 16 for WB

  1026.     int8_t  lsf_i1, lsf_i2[16];  // stage-1 and stage-2 codebook indices

  1027.     int16_t lsf_res[16];         // residual as a Q10 value

  1028.     int16_t nlsf[16];            // Q15

  1029. 

  1030.     *lpc_order = order = s->wb ? 16 : 10;

  1031. 

  1032.     /* obtain LSF stage-1 and stage-2 indices */

  1033.     lsf_i1 = opus_rc_getsymbol(rc, silk_model_lsf_s1[s->wb][voiced]);

  1034.     for (i = 0; i < order; i++) {

  1035.         int index = s->wb ? silk_lsf_s2_model_sel_wb  [lsf_i1][i] :

  1036.                             silk_lsf_s2_model_sel_nbmb[lsf_i1][i];

  1037.         lsf_i2[i] = opus_rc_getsymbol(rc, silk_model_lsf_s2[index]) - 4;

  1038.         if (lsf_i2[i] == -4)

  1039.             lsf_i2[i] -= opus_rc_getsymbol(rc, silk_model_lsf_s2_ext);

  1040.         else if (lsf_i2[i] == 4)

  1041.             lsf_i2[i] += opus_rc_getsymbol(rc, silk_model_lsf_s2_ext);

  1042.     }

  1043. 

  1044.     /* reverse the backwards-prediction step */

  1045.     for (i = order - 1; i >= 0; i--) {

  1046.         int qstep = s->wb ? 9830 : 11796;

  1047. 

  1048.         lsf_res[i] = lsf_i2[i] * 1024;

  1049.         if (lsf_i2[i] < 0)      lsf_res[i] += 102;

  1050.         else if (lsf_i2[i] > 0) lsf_res[i] -= 102;

  1051.         lsf_res[i] = (lsf_res[i] * qstep) >> 16;

  1052. 

  1053.         if (i + 1 < order) {

  1054.             int weight = s->wb ? silk_lsf_pred_weights_wb  [silk_lsf_weight_sel_wb  [lsf_i1][i]][i] :

  1055.                                  silk_lsf_pred_weights_nbmb[silk_lsf_weight_sel_nbmb[lsf_i1][i]][i];

  1056.             lsf_res[i] += (lsf_res[i+1] * weight) >> 8;

  1057.         }

  1058.     }

  1059. 

  1060.     /* reconstruct the NLSF coefficients from the supplied indices */

  1061.     for (i = 0; i < order; i++) {

  1062.         const uint8_t * codebook = s->wb ? silk_lsf_codebook_wb  [lsf_i1] :

  1063.                                            silk_lsf_codebook_nbmb[lsf_i1];

  1064.         int cur, prev, next, weight_sq, weight, ipart, fpart, y, value;

  1065. 

  1066.         /* find the weight of the residual */

  1067.         /* TODO: precompute */

  1068.         cur = codebook[i];

  1069.         prev = i ? codebook[i - 1] : 0;

  1070.         next = i + 1 < order ? codebook[i + 1] : 256;

  1071.         weight_sq = (1024 / (cur - prev) + 1024 / (next - cur)) << 16;

  1072. 

  1073.         /* approximate square-root with mandated fixed-point arithmetic */

  1074.         ipart = opus_ilog(weight_sq);

  1075.         fpart = (weight_sq >> (ipart-8)) & 127;

  1076.         y = ((ipart & 1) ? 32768 : 46214) >> ((32 - ipart)>>1);

  1077.         weight = y + ((213 * fpart * y) >> 16);

  1078. 

  1079.         value = cur * 128 + (lsf_res[i] * 16384) / weight;

  1080.         nlsf[i] = av_clip_uintp2(value, 15);

  1081.     }

  1082. 

  1083.     /* stabilize the NLSF coefficients */

  1084.     silk_stabilize_lsf(nlsf, order, s->wb ? silk_lsf_min_spacing_wb :

  1085.                                             silk_lsf_min_spacing_nbmb);

  1086. 

  1087.     /* produce an interpolation for the first 2 subframes, */

  1088.     /* and then convert both sets of NLSFs to LPC coefficients */

  1089.     *has_lpc_leadin = 0;

  1090.     if (s->subframes == 4) {

  1091.         int offset = opus_rc_getsymbol(rc, silk_model_lsf_interpolation_offset);

  1092.         if (offset != 4 && frame->coded) {

  1093.             *has_lpc_leadin = 1;

  1094.             if (offset != 0) {

  1095.                 int16_t nlsf_leadin[16];

  1096.                 for (i = 0; i < order; i++)

  1097.                     nlsf_leadin[i] = frame->nlsf[i] +

  1098.                         ((nlsf[i] - frame->nlsf[i]) * offset >> 2);

  1099.                 silk_lsf2lpc(nlsf_leadin, lpc_leadin, order);

  1100.             } else  /* avoid re-computation for a (roughly) 1-in-4 occurrence */

  1101.                 memcpy(lpc_leadin, frame->lpc, 16 * sizeof(float));

  1102.         } else

  1103.             offset = 4;

  1104.         s->nlsf_interp_factor = offset;

  1105. 

  1106.         silk_lsf2lpc(nlsf, lpc, order);

  1107.     } else {

  1108.         s->nlsf_interp_factor = 4;

  1109.         silk_lsf2lpc(nlsf, lpc, order);

  1110.     }

  1111. 

  1112.     memcpy(frame->nlsf, nlsf, order * sizeof(nlsf[0]));

  1113.     memcpy(frame->lpc,  lpc,  order * sizeof(lpc[0]));

  1114. }

  1115. 

  1116. static inline void silk_count_children(OpusRangeCoder *rc, int model, int32_t total,

  1117.                                        int32_t child[2])

  1118. {

  1119.     if (total != 0) {

  1120.         child[0] = opus_rc_getsymbol(rc,

  1121.                        silk_model_pulse_location[model] + (((total - 1 + 5) * (total - 1)) >> 1));

  1122.         child[1] = total - child[0];

  1123.     } else {

  1124.         child[0] = 0;

  1125.         child[1] = 0;

  1126.     }

  1127. }

  1128. 

  1129. static inline void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc,

  1130.                                           float* excitationf,

  1131.                                           int qoffset_high, int active, int voiced)

  1132. {

  1133.     int i;

  1134.     uint32_t seed;

  1135.     int shellblocks;

  1136.     int ratelevel;

  1137.     uint8_t pulsecount[20];     // total pulses in each shell block

  1138.     uint8_t lsbcount[20] = {0}; // raw lsbits defined for each pulse in each shell block

  1139.     int32_t excitation[320];    // Q23

  1140. 

  1141.     /* excitation parameters */

  1142.     seed = opus_rc_getsymbol(rc, silk_model_lcg_seed);

  1143.     shellblocks = silk_shell_blocks[s->bandwidth][s->subframes >> 2];

  1144.     ratelevel = opus_rc_getsymbol(rc, silk_model_exc_rate[voiced]);

  1145. 

  1146.     for (i = 0; i < shellblocks; i++) {

  1147.         pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[ratelevel]);

  1148.         if (pulsecount[i] == 17) {

  1149.             while (pulsecount[i] == 17 && ++lsbcount[i] != 10)

  1150.                 pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[9]);

  1151.             if (lsbcount[i] == 10)

  1152.                 pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[10]);

  1153.         }

  1154.     }

  1155. 

  1156.     /* decode pulse locations using PVQ */

  1157.     for (i = 0; i < shellblocks; i++) {

  1158.         if (pulsecount[i] != 0) {

  1159.             int a, b, c, d;

  1160.             int32_t * location = excitation + 16*i;

  1161.             int32_t branch[4][2];

  1162.             branch[0][0] = pulsecount[i];

  1163. 

  1164.             /* unrolled tail recursion */

  1165.             for (a = 0; a < 1; a++) {

  1166.                 silk_count_children(rc, 0, branch[0][a], branch[1]);

  1167.                 for (b = 0; b < 2; b++) {

  1168.                     silk_count_children(rc, 1, branch[1][b], branch[2]);

  1169.                     for (c = 0; c < 2; c++) {

  1170.                         silk_count_children(rc, 2, branch[2][c], branch[3]);

  1171.                         for (d = 0; d < 2; d++) {

  1172.                             silk_count_children(rc, 3, branch[3][d], location);

  1173.                             location += 2;

  1174.                         }

  1175.                     }

  1176.                 }

  1177.             }

  1178.         } else

  1179.             memset(excitation + 16*i, 0, 16*sizeof(int32_t));

  1180.     }

  1181. 

  1182.     /* decode least significant bits */

  1183.     for (i = 0; i < shellblocks << 4; i++) {

  1184.         int bit;

  1185.         for (bit = 0; bit < lsbcount[i >> 4]; bit++)

  1186.             excitation[i] = (excitation[i] << 1) |

  1187.                             opus_rc_getsymbol(rc, silk_model_excitation_lsb);

  1188.     }

  1189. 

  1190.     /* decode signs */

  1191.     for (i = 0; i < shellblocks << 4; i++) {

  1192.         if (excitation[i] != 0) {

  1193.             int sign = opus_rc_getsymbol(rc, silk_model_excitation_sign[active +

  1194.                                          voiced][qoffset_high][FFMIN(pulsecount[i >> 4], 6)]);

  1195.             if (sign == 0)

  1196.                 excitation[i] *= -1;

  1197.         }

  1198.     }

  1199. 

  1200.     /* assemble the excitation */

  1201.     for (i = 0; i < shellblocks << 4; i++) {

  1202.         int value = excitation[i];

  1203.         excitation[i] = value * 256 | silk_quant_offset[voiced][qoffset_high];

  1204.         if (value < 0)      excitation[i] += 20;

  1205.         else if (value > 0) excitation[i] -= 20;

  1206. 

  1207.         /* invert samples pseudorandomly */

  1208.         seed = 196314165 * seed + 907633515;

  1209.         if (seed & 0x80000000)

  1210.             excitation[i] *= -1;

  1211.         seed += value;

  1212. 

  1213.         excitationf[i] = excitation[i] / 8388608.0f;

  1214.     }

  1215. }

  1216. 

  1217. /** Maximum residual history according to 4.2.7.6.1 */

  1218. #define SILK_MAX_LAG  (288 + LTP_ORDER / 2)

  1219. 

  1220. /** Order of the LTP filter */

  1221. #define LTP_ORDER 5

  1222. 

  1223. static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,

  1224.                               int frame_num, int channel, int coded_channels, int active, int active1)

  1225. {

  1226.     /* per frame */

  1227.     int voiced;       // combines with active to indicate inactive, active, or active+voiced

  1228.     int qoffset_high;

  1229.     int order;                             // order of the LPC coefficients

  1230.     float lpc_leadin[16], lpc_body[16], residual[SILK_MAX_LAG + SILK_HISTORY];

  1231.     int has_lpc_leadin;

  1232.     float ltpscale;

  1233. 

  1234.     /* per subframe */

  1235.     struct {

  1236.         float gain;

  1237.         int pitchlag;

  1238.         float ltptaps[5];

  1239.     } sf[4];

  1240. 

  1241.     SilkFrame * const frame = s->frame + channel;

  1242. 

  1243.     int i;

  1244. 

  1245.     /* obtain stereo weights */

  1246.     if (coded_channels == 2 && channel == 0) {

  1247.         int n, wi[2], ws[2], w[2];

  1248.         n     = opus_rc_getsymbol(rc, silk_model_stereo_s1);

  1249.         wi[0] = opus_rc_getsymbol(rc, silk_model_stereo_s2) + 3 * (n / 5);

  1250.         ws[0] = opus_rc_getsymbol(rc, silk_model_stereo_s3);

  1251.         wi[1] = opus_rc_getsymbol(rc, silk_model_stereo_s2) + 3 * (n % 5);

  1252.         ws[1] = opus_rc_getsymbol(rc, silk_model_stereo_s3);

  1253. 

  1254.         for (i = 0; i < 2; i++)

  1255.             w[i] = silk_stereo_weights[wi[i]] +

  1256.                    (((silk_stereo_weights[wi[i] + 1] - silk_stereo_weights[wi[i]]) * 6554) >> 16)

  1257.                     * (ws[i]*2 + 1);

  1258. 

  1259.         s->stereo_weights[0] = (w[0] - w[1]) / 8192.0;

  1260.         s->stereo_weights[1] = w[1]          / 8192.0;

  1261. 

  1262.         /* and read the mid-only flag */

  1263.         s->midonly = active1 ? 0 : opus_rc_getsymbol(rc, silk_model_mid_only);

  1264.     }

  1265. 

  1266.     /* obtain frame type */

  1267.     if (!active) {

  1268.         qoffset_high = opus_rc_getsymbol(rc, silk_model_frame_type_inactive);

  1269.         voiced = 0;

  1270.     } else {

  1271.         int type = opus_rc_getsymbol(rc, silk_model_frame_type_active);

  1272.         qoffset_high = type & 1;

  1273.         voiced = type >> 1;

  1274.     }

  1275. 

  1276.     /* obtain subframe quantization gains */

  1277.     for (i = 0; i < s->subframes; i++) {

  1278.         int log_gain;     //Q7

  1279.         int ipart, fpart, lingain;

  1280. 

  1281.         if (i == 0 && (frame_num == 0 || !frame->coded)) {

  1282.             /* gain is coded absolute */

  1283.             int x = opus_rc_getsymbol(rc, silk_model_gain_highbits[active + voiced]);

  1284.             log_gain = (x<<3) | opus_rc_getsymbol(rc, silk_model_gain_lowbits);

  1285. 

  1286.             if (frame->coded)

  1287.                 log_gain = FFMAX(log_gain, frame->log_gain - 16);

  1288.         } else {

  1289.             /* gain is coded relative */

  1290.             int delta_gain = opus_rc_getsymbol(rc, silk_model_gain_delta);

  1291.             log_gain = av_clip_uintp2(FFMAX((delta_gain<<1) - 16,

  1292.                                      frame->log_gain + delta_gain - 4), 6);

  1293.         }

  1294. 

  1295.         frame->log_gain = log_gain;

  1296. 

  1297.         /* approximate 2**(x/128) with a Q7 (i.e. non-integer) input */

  1298.         log_gain = (log_gain * 0x1D1C71 >> 16) + 2090;

  1299.         ipart = log_gain >> 7;

  1300.         fpart = log_gain & 127;

  1301.         lingain = (1 << ipart) + ((-174 * fpart * (128-fpart) >>16) + fpart) * ((1<<ipart) >> 7);

  1302.         sf[i].gain = lingain / 65536.0f;

  1303.     }

  1304. 

  1305.     /* obtain LPC filter coefficients */

  1306.     silk_decode_lpc(s, frame, rc, lpc_leadin, lpc_body, &order, &has_lpc_leadin, voiced);

  1307. 

  1308.     /* obtain pitch lags, if this is a voiced frame */

  1309.     if (voiced) {

  1310.         int lag_absolute = (!frame_num || !frame->prev_voiced);

  1311.         int primarylag;         // primary pitch lag for the entire SILK frame

  1312.         int ltpfilter;

  1313.         const int8_t * offsets;

  1314. 

  1315.         if (!lag_absolute) {

  1316.             int delta = opus_rc_getsymbol(rc, silk_model_pitch_delta);

  1317.             if (delta)

  1318.                 primarylag = frame->primarylag + delta - 9;

  1319.             else

  1320.                 lag_absolute = 1;

  1321.         }

  1322. 

  1323.         if (lag_absolute) {

  1324.             /* primary lag is coded absolute */

  1325.             int highbits, lowbits;

  1326.             static const uint16_t * const model[] = {

  1327.                 silk_model_pitch_lowbits_nb, silk_model_pitch_lowbits_mb,

  1328.                 silk_model_pitch_lowbits_wb

  1329.             };

  1330.             highbits = opus_rc_getsymbol(rc, silk_model_pitch_highbits);

  1331.             lowbits  = opus_rc_getsymbol(rc, model[s->bandwidth]);

  1332. 

  1333.             primarylag = silk_pitch_min_lag[s->bandwidth] +

  1334.                          highbits*silk_pitch_scale[s->bandwidth] + lowbits;

  1335.         }

  1336.         frame->primarylag = primarylag;

  1337. 

  1338.         if (s->subframes == 2)

  1339.             offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)

  1340.                      ? silk_pitch_offset_nb10ms[opus_rc_getsymbol(rc,

  1341.                                                 silk_model_pitch_contour_nb10ms)]

  1342.                      : silk_pitch_offset_mbwb10ms[opus_rc_getsymbol(rc,

  1343.                                                 silk_model_pitch_contour_mbwb10ms)];

  1344.         else

  1345.             offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)

  1346.                      ? silk_pitch_offset_nb20ms[opus_rc_getsymbol(rc,

  1347.                                                 silk_model_pitch_contour_nb20ms)]

  1348.                      : silk_pitch_offset_mbwb20ms[opus_rc_getsymbol(rc,

  1349.                                                 silk_model_pitch_contour_mbwb20ms)];

  1350. 

  1351.         for (i = 0; i < s->subframes; i++)

  1352.             sf[i].pitchlag = av_clip(primarylag + offsets[i],

  1353.                                      silk_pitch_min_lag[s->bandwidth],

  1354.                                      silk_pitch_max_lag[s->bandwidth]);

  1355. 

  1356.         /* obtain LTP filter coefficients */

  1357.         ltpfilter = opus_rc_getsymbol(rc, silk_model_ltp_filter);

  1358.         for (i = 0; i < s->subframes; i++) {

  1359.             int index, j;

  1360.             static const uint16_t * const filter_sel[] = {

  1361.                 silk_model_ltp_filter0_sel, silk_model_ltp_filter1_sel,

  1362.                 silk_model_ltp_filter2_sel

  1363.             };

  1364.             static const int8_t (* const filter_taps[])[5] = {

  1365.                 silk_ltp_filter0_taps, silk_ltp_filter1_taps, silk_ltp_filter2_taps

  1366.             };

  1367.             index = opus_rc_getsymbol(rc, filter_sel[ltpfilter]);

  1368.             for (j = 0; j < 5; j++)

  1369.                 sf[i].ltptaps[j] = filter_taps[ltpfilter][index][j] / 128.0f;

  1370.         }

  1371.     }

  1372. 

  1373.     /* obtain LTP scale factor */

  1374.     if (voiced && frame_num == 0)

  1375.         ltpscale = silk_ltp_scale_factor[opus_rc_getsymbol(rc,

  1376.                                          silk_model_ltp_scale_index)] / 16384.0f;

  1377.     else ltpscale = 15565.0f/16384.0f;

  1378. 

  1379.     /* generate the excitation signal for the entire frame */

  1380.     silk_decode_excitation(s, rc, residual + SILK_MAX_LAG, qoffset_high,

  1381.                            active, voiced);

  1382. 

  1383.     /* skip synthesising the side channel if we want mono-only */

  1384.     if (s->output_channels == channel)

  1385.         return;

  1386. 

  1387.     /* generate the output signal */

  1388.     for (i = 0; i < s->subframes; i++) {

  1389.         const float * lpc_coeff = (i < 2 && has_lpc_leadin) ? lpc_leadin : lpc_body;

  1390.         float *dst    = frame->output      + SILK_HISTORY + i * s->sflength;

  1391.         float *resptr = residual           + SILK_MAX_LAG + i * s->sflength;

  1392.         float *lpc    = frame->lpc_history + SILK_HISTORY + i * s->sflength;

  1393.         float sum;

  1394.         int j, k;

  1395. 

  1396.         if (voiced) {

  1397.             int out_end;

  1398.             float scale;

  1399. 

  1400.             if (i < 2 || s->nlsf_interp_factor == 4) {

  1401.                 out_end = -i * s->sflength;

  1402.                 scale   = ltpscale;

  1403.             } else {

  1404.                 out_end = -(i - 2) * s->sflength;

  1405.                 scale   = 1.0f;

  1406.             }

  1407. 

  1408.             /* when the LPC coefficients change, a re-whitening filter is used */

  1409.             /* to produce a residual that accounts for the change */

  1410.             for (j = - sf[i].pitchlag - LTP_ORDER/2; j < out_end; j++) {

  1411.                 sum = dst[j];

  1412.                 for (k = 0; k < order; k++)

  1413.                     sum -= lpc_coeff[k] * dst[j - k - 1];

  1414.                 resptr[j] = av_clipf(sum, -1.0f, 1.0f) * scale / sf[i].gain;

  1415.             }

  1416. 

  1417.             if (out_end) {

  1418.                 float rescale = sf[i-1].gain / sf[i].gain;

  1419.                 for (j = out_end; j < 0; j++)

  1420.                     resptr[j] *= rescale;

  1421.             }

  1422. 

  1423.             /* LTP synthesis */

  1424.             for (j = 0; j < s->sflength; j++) {

  1425.                 sum = resptr[j];

  1426.                 for (k = 0; k < LTP_ORDER; k++)

  1427.                     sum += sf[i].ltptaps[k] * resptr[j - sf[i].pitchlag + LTP_ORDER/2 - k];

  1428.                 resptr[j] = sum;

  1429.             }

  1430.         }

  1431. 

  1432.         /* LPC synthesis */

  1433.         for (j = 0; j < s->sflength; j++) {

  1434.             sum = resptr[j] * sf[i].gain;

  1435.             for (k = 1; k <= order; k++)

  1436.                 sum += lpc_coeff[k - 1] * lpc[j - k];

  1437. 

  1438.             lpc[j] = sum;

  1439.             dst[j] = av_clipf(sum, -1.0f, 1.0f);

  1440.         }

  1441.     }

  1442. 

  1443.     frame->prev_voiced = voiced;

  1444.     memmove(frame->lpc_history, frame->lpc_history + s->flength, SILK_HISTORY * sizeof(float));

  1445.     memmove(frame->output,      frame->output      + s->flength, SILK_HISTORY * sizeof(float));

  1446. 

  1447.     frame->coded = 1;

  1448. }

  1449. 

  1450. static void silk_unmix_ms(SilkContext *s, float *l, float *r)

  1451. {

  1452.     float *mid    = s->frame[0].output + SILK_HISTORY - s->flength;

  1453.     float *side   = s->frame[1].output + SILK_HISTORY - s->flength;

  1454.     float w0_prev = s->prev_stereo_weights[0];

  1455.     float w1_prev = s->prev_stereo_weights[1];

  1456.     float w0      = s->stereo_weights[0];

  1457.     float w1      = s->stereo_weights[1];

  1458.     int n1        = silk_stereo_interp_len[s->bandwidth];

  1459.     int i;

  1460. 

  1461.     for (i = 0; i < n1; i++) {

  1462.         float interp0 = w0_prev + i * (w0 - w0_prev) / n1;

  1463.         float interp1 = w1_prev + i * (w1 - w1_prev) / n1;

  1464.         float p0      = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);

  1465. 

  1466.         l[i] = av_clipf((1 + interp1) * mid[i - 1] + side[i - 1] + interp0 * p0, -1.0, 1.0);

  1467.         r[i] = av_clipf((1 - interp1) * mid[i - 1] - side[i - 1] - interp0 * p0, -1.0, 1.0);

  1468.     }

  1469. 

  1470.     for (; i < s->flength; i++) {

  1471.         float p0 = 0.25 * (mid[i - 2] + 2 * mid[i - 1] + mid[i]);

  1472. 

  1473.         l[i] = av_clipf((1 + w1) * mid[i - 1] + side[i - 1] + w0 * p0, -1.0, 1.0);

  1474.         r[i] = av_clipf((1 - w1) * mid[i - 1] - side[i - 1] - w0 * p0, -1.0, 1.0);

  1475.     }

  1476. 

  1477.     memcpy(s->prev_stereo_weights, s->stereo_weights, sizeof(s->stereo_weights));

  1478. }

  1479. 

  1480. static void silk_flush_frame(SilkFrame *frame)

  1481. {

  1482.     if (!frame->coded)

  1483.         return;

  1484. 

  1485.     memset(frame->output,      0, sizeof(frame->output));

  1486.     memset(frame->lpc_history, 0, sizeof(frame->lpc_history));

  1487. 

  1488.     memset(frame->lpc,  0, sizeof(frame->lpc));

  1489.     memset(frame->nlsf, 0, sizeof(frame->nlsf));

  1490. 

  1491.     frame->log_gain = 0;

  1492. 

  1493.     frame->primarylag  = 0;

  1494.     frame->prev_voiced = 0;

  1495.     frame->coded       = 0;

  1496. }

  1497. 

  1498. int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,

  1499.                               float *output[2],

  1500.                               enum OpusBandwidth bandwidth,

  1501.                               int coded_channels,

  1502.                               int duration_ms)

  1503. {

  1504.     int active[2][6], redundancy[2];

  1505.     int nb_frames, i, j;

  1506. 

  1507.     if (bandwidth > OPUS_BANDWIDTH_WIDEBAND ||

  1508.         coded_channels > 2 || duration_ms > 60) {

  1509.         av_log(s->avctx, AV_LOG_ERROR, "Invalid parameters passed "

  1510.                "to the SILK decoder.\n");

  1511.         return AVERROR(EINVAL);

  1512.     }

  1513. 

  1514.     nb_frames = 1 + (duration_ms > 20) + (duration_ms > 40);

  1515.     s->subframes = duration_ms / nb_frames / 5;         // 5ms subframes

  1516.     s->sflength  = 20 * (bandwidth + 2);

  1517.     s->flength   = s->sflength * s->subframes;

  1518.     s->bandwidth = bandwidth;

  1519.     s->wb        = bandwidth == OPUS_BANDWIDTH_WIDEBAND;

  1520. 

  1521.     /* make sure to flush the side channel when switching from mono to stereo */

  1522.     if (coded_channels > s->prev_coded_channels)

  1523.         silk_flush_frame(&s->frame[1]);

  1524.     s->prev_coded_channels = coded_channels;

  1525. 

  1526.     /* read the LP-layer header bits */

  1527.     for (i = 0; i < coded_channels; i++) {

  1528.         for (j = 0; j < nb_frames; j++)

  1529.             active[i][j] = opus_rc_p2model(rc, 1);

  1530. 

  1531.         redundancy[i] = opus_rc_p2model(rc, 1);

  1532.         if (redundancy[i]) {

  1533.             avpriv_report_missing_feature(s->avctx, "LBRR frames");

  1534.             return AVERROR_PATCHWELCOME;

  1535.         }

  1536.     }

  1537. 

  1538.     for (i = 0; i < nb_frames; i++) {

  1539.         for (j = 0; j < coded_channels && !s->midonly; j++)

  1540.             silk_decode_frame(s, rc, i, j, coded_channels, active[j][i], active[1][i]);

  1541. 

  1542.         /* reset the side channel if it is not coded */

  1543.         if (s->midonly && s->frame[1].coded)

  1544.             silk_flush_frame(&s->frame[1]);

  1545. 

  1546.         if (coded_channels == 1 || s->output_channels == 1) {

  1547.             for (j = 0; j < s->output_channels; j++) {

  1548.                 memcpy(output[j] + i * s->flength,

  1549.                        s->frame[0].output + SILK_HISTORY - s->flength - 2,

  1550.                        s->flength * sizeof(float));

  1551.             }

  1552.         } else {

  1553.             silk_unmix_ms(s, output[0] + i * s->flength, output[1] + i * s->flength);

  1554.         }

  1555. 

  1556.         s->midonly        = 0;

  1557.     }

  1558. 

  1559.     return nb_frames * s->flength;

  1560. }

  1561. 

  1562. void ff_silk_free(SilkContext **ps)

  1563. {

  1564.     av_freep(ps);

  1565. }

  1566. 

  1567. void ff_silk_flush(SilkContext *s)

  1568. {

  1569.     silk_flush_frame(&s->frame[0]);

  1570.     silk_flush_frame(&s->frame[1]);

  1571. 

  1572.     memset(s->prev_stereo_weights, 0, sizeof(s->prev_stereo_weights));

  1573. }

  1574. 

  1575. int ff_silk_init(AVCodecContext *avctx, SilkContext **ps, int output_channels)

  1576. {

  1577.     SilkContext *s;

  1578. 

  1579.     if (output_channels != 1 && output_channels != 2) {

  1580.         av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",

  1581.                output_channels);

  1582.         return AVERROR(EINVAL);

  1583.     }

  1584. 

  1585.     s = av_mallocz(sizeof(*s));

  1586.     if (!s)

  1587.         return AVERROR(ENOMEM);

  1588. 

  1589.     s->avctx           = avctx;

  1590.     s->output_channels = output_channels;

  1591. 

  1592.     ff_silk_flush(s);

  1593. 

  1594.     *ps = s;

  1595. 

  1596.     return 0;

  1597. }