Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2012 Andrew D'Addesio
  3.  * Copyright (c) 2013-2014 Mozilla Corporation
  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. /**
  23.  * @file
  24.  * Opus CELT decoder
  25.  */
  26.  
  27. #include <stdint.h>
  28.  
  29. #include "libavutil/float_dsp.h"
  30.  
  31. #include "imdct15.h"
  32. #include "opus.h"
  33.  
  34. enum CeltSpread {
  35.     CELT_SPREAD_NONE,
  36.     CELT_SPREAD_LIGHT,
  37.     CELT_SPREAD_NORMAL,
  38.     CELT_SPREAD_AGGRESSIVE
  39. };
  40.  
  41. typedef struct CeltFrame {
  42.     float energy[CELT_MAX_BANDS];
  43.     float prev_energy[2][CELT_MAX_BANDS];
  44.  
  45.     uint8_t collapse_masks[CELT_MAX_BANDS];
  46.  
  47.     /* buffer for mdct output + postfilter */
  48.     DECLARE_ALIGNED(32, float, buf)[2048];
  49.  
  50.     /* postfilter parameters */
  51.     int pf_period_new;
  52.     float pf_gains_new[3];
  53.     int pf_period;
  54.     float pf_gains[3];
  55.     int pf_period_old;
  56.     float pf_gains_old[3];
  57.  
  58.     float deemph_coeff;
  59. } CeltFrame;
  60.  
  61. struct CeltContext {
  62.     // constant values that do not change during context lifetime
  63.     AVCodecContext    *avctx;
  64.     IMDCT15Context    *imdct[4];
  65.     AVFloatDSPContext  *dsp;
  66.     int output_channels;
  67.  
  68.     // values that have inter-frame effect and must be reset on flush
  69.     CeltFrame frame[2];
  70.     uint32_t seed;
  71.     int flushed;
  72.  
  73.     // values that only affect a single frame
  74.     int coded_channels;
  75.     int framebits;
  76.     int duration;
  77.  
  78.     /* number of iMDCT blocks in the frame */
  79.     int blocks;
  80.     /* size of each block */
  81.     int blocksize;
  82.  
  83.     int startband;
  84.     int endband;
  85.     int codedbands;
  86.  
  87.     int anticollapse_bit;
  88.  
  89.     int intensitystereo;
  90.     int dualstereo;
  91.     enum CeltSpread spread;
  92.  
  93.     int remaining;
  94.     int remaining2;
  95.     int fine_bits    [CELT_MAX_BANDS];
  96.     int fine_priority[CELT_MAX_BANDS];
  97.     int pulses       [CELT_MAX_BANDS];
  98.     int tf_change    [CELT_MAX_BANDS];
  99.  
  100.     DECLARE_ALIGNED(32, float, coeffs)[2][CELT_MAX_FRAME_SIZE];
  101.     DECLARE_ALIGNED(32, float, scratch)[22 * 8]; // MAX(celt_freq_range) * 1<<CELT_MAX_LOG_BLOCKS
  102. };
  103.  
  104. static const uint16_t celt_model_tapset[] = { 4, 2, 3, 4 };
  105.  
  106. static const uint16_t celt_model_spread[] = { 32, 7, 9, 30, 32 };
  107.  
  108. static const uint16_t celt_model_alloc_trim[] = {
  109.     128,   2,   4,   9,  19,  41,  87, 109, 119, 124, 126, 128
  110. };
  111.  
  112. static const uint16_t celt_model_energy_small[] = { 4, 2, 3, 4 };
  113.  
  114. static const uint8_t celt_freq_bands[] = { /* in steps of 200Hz */
  115.     0,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
  116. };
  117.  
  118. static const uint8_t celt_freq_range[] = {
  119.     1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  4,  4,  4,  6,  6,  8, 12, 18, 22
  120. };
  121.  
  122. static const uint8_t celt_log_freq_range[] = {
  123.     0,  0,  0,  0,  0,  0,  0,  0,  8,  8,  8,  8, 16, 16, 16, 21, 21, 24, 29, 34, 36
  124. };
  125.  
  126. static const int8_t celt_tf_select[4][2][2][2] = {
  127.     { { { 0, -1 }, { 0, -1 } }, { { 0, -1 }, { 0, -1 } } },
  128.     { { { 0, -1 }, { 0, -2 } }, { { 1,  0 }, { 1, -1 } } },
  129.     { { { 0, -2 }, { 0, -3 } }, { { 2,  0 }, { 1, -1 } } },
  130.     { { { 0, -2 }, { 0, -3 } }, { { 3,  0 }, { 1, -1 } } }
  131. };
  132.  
  133. static const float celt_mean_energy[] = {
  134.     6.437500f, 6.250000f, 5.750000f, 5.312500f, 5.062500f,
  135.     4.812500f, 4.500000f, 4.375000f, 4.875000f, 4.687500f,
  136.     4.562500f, 4.437500f, 4.875000f, 4.625000f, 4.312500f,
  137.     4.500000f, 4.375000f, 4.625000f, 4.750000f, 4.437500f,
  138.     3.750000f, 3.750000f, 3.750000f, 3.750000f, 3.750000f
  139. };
  140.  
  141. static const float celt_alpha_coef[] = {
  142.     29440.0f/32768.0f,    26112.0f/32768.0f,    21248.0f/32768.0f,    16384.0f/32768.0f
  143. };
  144.  
  145. static const float celt_beta_coef[] = { /* TODO: precompute 1 minus this if the code ends up neater */
  146.     30147.0f/32768.0f,    22282.0f/32768.0f,    12124.0f/32768.0f,     6554.0f/32768.0f
  147. };
  148.  
  149. static const uint8_t celt_coarse_energy_dist[4][2][42] = {
  150.     {
  151.         {       // 120-sample inter
  152.              72, 127,  65, 129,  66, 128,  65, 128,  64, 128,  62, 128,  64, 128,
  153.              64, 128,  92,  78,  92,  79,  92,  78,  90,  79, 116,  41, 115,  40,
  154.             114,  40, 132,  26, 132,  26, 145,  17, 161,  12, 176,  10, 177,  11
  155.         }, {    // 120-sample intra
  156.              24, 179,  48, 138,  54, 135,  54, 132,  53, 134,  56, 133,  55, 132,
  157.              55, 132,  61, 114,  70,  96,  74,  88,  75,  88,  87,  74,  89,  66,
  158.              91,  67, 100,  59, 108,  50, 120,  40, 122,  37,  97,  43,  78,  50
  159.         }
  160.     }, {
  161.         {       // 240-sample inter
  162.              83,  78,  84,  81,  88,  75,  86,  74,  87,  71,  90,  73,  93,  74,
  163.              93,  74, 109,  40, 114,  36, 117,  34, 117,  34, 143,  17, 145,  18,
  164.             146,  19, 162,  12, 165,  10, 178,   7, 189,   6, 190,   8, 177,   9
  165.         }, {    // 240-sample intra
  166.              23, 178,  54, 115,  63, 102,  66,  98,  69,  99,  74,  89,  71,  91,
  167.              73,  91,  78,  89,  86,  80,  92,  66,  93,  64, 102,  59, 103,  60,
  168.             104,  60, 117,  52, 123,  44, 138,  35, 133,  31,  97,  38,  77,  45
  169.         }
  170.     }, {
  171.         {       // 480-sample inter
  172.              61,  90,  93,  60, 105,  42, 107,  41, 110,  45, 116,  38, 113,  38,
  173.             112,  38, 124,  26, 132,  27, 136,  19, 140,  20, 155,  14, 159,  16,
  174.             158,  18, 170,  13, 177,  10, 187,   8, 192,   6, 175,   9, 159,  10
  175.         }, {    // 480-sample intra
  176.              21, 178,  59, 110,  71,  86,  75,  85,  84,  83,  91,  66,  88,  73,
  177.              87,  72,  92,  75,  98,  72, 105,  58, 107,  54, 115,  52, 114,  55,
  178.             112,  56, 129,  51, 132,  40, 150,  33, 140,  29,  98,  35,  77,  42
  179.         }
  180.     }, {
  181.         {       // 960-sample inter
  182.              42, 121,  96,  66, 108,  43, 111,  40, 117,  44, 123,  32, 120,  36,
  183.             119,  33, 127,  33, 134,  34, 139,  21, 147,  23, 152,  20, 158,  25,
  184.             154,  26, 166,  21, 173,  16, 184,  13, 184,  10, 150,  13, 139,  15
  185.         }, {    // 960-sample intra
  186.              22, 178,  63, 114,  74,  82,  84,  83,  92,  82, 103,  62,  96,  72,
  187.              96,  67, 101,  73, 107,  72, 113,  55, 118,  52, 125,  52, 118,  52,
  188.             117,  55, 135,  49, 137,  39, 157,  32, 145,  29,  97,  33,  77,  40
  189.         }
  190.     }
  191. };
  192.  
  193. static const uint8_t celt_static_alloc[11][21] = {  /* 1/32 bit/sample */
  194.     {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0 },
  195.     {  90,  80,  75,  69,  63,  56,  49,  40,  34,  29,  20,  18,  10,   0,   0,   0,   0,   0,   0,   0,   0 },
  196.     { 110, 100,  90,  84,  78,  71,  65,  58,  51,  45,  39,  32,  26,  20,  12,   0,   0,   0,   0,   0,   0 },
  197.     { 118, 110, 103,  93,  86,  80,  75,  70,  65,  59,  53,  47,  40,  31,  23,  15,   4,   0,   0,   0,   0 },
  198.     { 126, 119, 112, 104,  95,  89,  83,  78,  72,  66,  60,  54,  47,  39,  32,  25,  17,  12,   1,   0,   0 },
  199.     { 134, 127, 120, 114, 103,  97,  91,  85,  78,  72,  66,  60,  54,  47,  41,  35,  29,  23,  16,  10,   1 },
  200.     { 144, 137, 130, 124, 113, 107, 101,  95,  88,  82,  76,  70,  64,  57,  51,  45,  39,  33,  26,  15,   1 },
  201.     { 152, 145, 138, 132, 123, 117, 111, 105,  98,  92,  86,  80,  74,  67,  61,  55,  49,  43,  36,  20,   1 },
  202.     { 162, 155, 148, 142, 133, 127, 121, 115, 108, 102,  96,  90,  84,  77,  71,  65,  59,  53,  46,  30,   1 },
  203.     { 172, 165, 158, 152, 143, 137, 131, 125, 118, 112, 106, 100,  94,  87,  81,  75,  69,  63,  56,  45,  20 },
  204.     { 200, 200, 200, 200, 200, 200, 200, 200, 198, 193, 188, 183, 178, 173, 168, 163, 158, 153, 148, 129, 104 }
  205. };
  206.  
  207. static const uint8_t celt_static_caps[4][2][21] = {
  208.     {       // 120-sample
  209.         {224, 224, 224, 224, 224, 224, 224, 224, 160, 160,
  210.          160, 160, 185, 185, 185, 178, 178, 168, 134,  61,  37},
  211.         {224, 224, 224, 224, 224, 224, 224, 224, 240, 240,
  212.          240, 240, 207, 207, 207, 198, 198, 183, 144,  66,  40},
  213.     }, {    // 240-sample
  214.         {160, 160, 160, 160, 160, 160, 160, 160, 185, 185,
  215.          185, 185, 193, 193, 193, 183, 183, 172, 138,  64,  38},
  216.         {240, 240, 240, 240, 240, 240, 240, 240, 207, 207,
  217.          207, 207, 204, 204, 204, 193, 193, 180, 143,  66,  40},
  218.     }, {    // 480-sample
  219.         {185, 185, 185, 185, 185, 185, 185, 185, 193, 193,
  220.          193, 193, 193, 193, 193, 183, 183, 172, 138,  65,  39},
  221.         {207, 207, 207, 207, 207, 207, 207, 207, 204, 204,
  222.          204, 204, 201, 201, 201, 188, 188, 176, 141,  66,  40},
  223.     }, {    // 960-sample
  224.         {193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
  225.          193, 193, 194, 194, 194, 184, 184, 173, 139,  65,  39},
  226.         {204, 204, 204, 204, 204, 204, 204, 204, 201, 201,
  227.          201, 201, 198, 198, 198, 187, 187, 175, 140,  66,  40}
  228.     }
  229. };
  230.  
  231. static const uint8_t celt_cache_bits[392] = {
  232.     40, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  233.     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  234.     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 40, 15, 23, 28,
  235.     31, 34, 36, 38, 39, 41, 42, 43, 44, 45, 46, 47, 47, 49, 50,
  236.     51, 52, 53, 54, 55, 55, 57, 58, 59, 60, 61, 62, 63, 63, 65,
  237.     66, 67, 68, 69, 70, 71, 71, 40, 20, 33, 41, 48, 53, 57, 61,
  238.     64, 66, 69, 71, 73, 75, 76, 78, 80, 82, 85, 87, 89, 91, 92,
  239.     94, 96, 98, 101, 103, 105, 107, 108, 110, 112, 114, 117, 119, 121, 123,
  240.     124, 126, 128, 40, 23, 39, 51, 60, 67, 73, 79, 83, 87, 91, 94,
  241.     97, 100, 102, 105, 107, 111, 115, 118, 121, 124, 126, 129, 131, 135, 139,
  242.     142, 145, 148, 150, 153, 155, 159, 163, 166, 169, 172, 174, 177, 179, 35,
  243.     28, 49, 65, 78, 89, 99, 107, 114, 120, 126, 132, 136, 141, 145, 149,
  244.     153, 159, 165, 171, 176, 180, 185, 189, 192, 199, 205, 211, 216, 220, 225,
  245.     229, 232, 239, 245, 251, 21, 33, 58, 79, 97, 112, 125, 137, 148, 157,
  246.     166, 174, 182, 189, 195, 201, 207, 217, 227, 235, 243, 251, 17, 35, 63,
  247.     86, 106, 123, 139, 152, 165, 177, 187, 197, 206, 214, 222, 230, 237, 250,
  248.     25, 31, 55, 75, 91, 105, 117, 128, 138, 146, 154, 161, 168, 174, 180,
  249.     185, 190, 200, 208, 215, 222, 229, 235, 240, 245, 255, 16, 36, 65, 89,
  250.     110, 128, 144, 159, 173, 185, 196, 207, 217, 226, 234, 242, 250, 11, 41,
  251.     74, 103, 128, 151, 172, 191, 209, 225, 241, 255, 9, 43, 79, 110, 138,
  252.     163, 186, 207, 227, 246, 12, 39, 71, 99, 123, 144, 164, 182, 198, 214,
  253.     228, 241, 253, 9, 44, 81, 113, 142, 168, 192, 214, 235, 255, 7, 49,
  254.     90, 127, 160, 191, 220, 247, 6, 51, 95, 134, 170, 203, 234, 7, 47,
  255.     87, 123, 155, 184, 212, 237, 6, 52, 97, 137, 174, 208, 240, 5, 57,
  256.     106, 151, 192, 231, 5, 59, 111, 158, 202, 243, 5, 55, 103, 147, 187,
  257.     224, 5, 60, 113, 161, 206, 248, 4, 65, 122, 175, 224, 4, 67, 127,
  258.     182, 234
  259. };
  260.  
  261. static const int16_t celt_cache_index[105] = {
  262.     -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 41, 41, 41,
  263.     82, 82, 123, 164, 200, 222, 0, 0, 0, 0, 0, 0, 0, 0, 41,
  264.     41, 41, 41, 123, 123, 123, 164, 164, 240, 266, 283, 295, 41, 41, 41,
  265.     41, 41, 41, 41, 41, 123, 123, 123, 123, 240, 240, 240, 266, 266, 305,
  266.     318, 328, 336, 123, 123, 123, 123, 123, 123, 123, 123, 240, 240, 240, 240,
  267.     305, 305, 305, 318, 318, 343, 351, 358, 364, 240, 240, 240, 240, 240, 240,
  268.     240, 240, 305, 305, 305, 305, 343, 343, 343, 351, 351, 370, 376, 382, 387,
  269. };
  270.  
  271. static const uint8_t celt_log2_frac[] = {
  272.     0, 8, 13, 16, 19, 21, 23, 24, 26, 27, 28, 29, 30, 31, 32, 32, 33, 34, 34, 35, 36, 36, 37, 37
  273. };
  274.  
  275. static const uint8_t celt_bit_interleave[] = {
  276.     0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3
  277. };
  278.  
  279. static const uint8_t celt_bit_deinterleave[] = {
  280.     0x00, 0x03, 0x0C, 0x0F, 0x30, 0x33, 0x3C, 0x3F,
  281.     0xC0, 0xC3, 0xCC, 0xCF, 0xF0, 0xF3, 0xFC, 0xFF
  282. };
  283.  
  284. static const uint8_t celt_hadamard_ordery[] = {
  285.     1,   0,
  286.     3,   0,  2,  1,
  287.     7,   0,  4,  3,  6,  1,  5,  2,
  288.     15,  0,  8,  7, 12,  3, 11,  4, 14,  1,  9,  6, 13,  2, 10,  5
  289. };
  290.  
  291. static const uint16_t celt_qn_exp2[] = {
  292.     16384, 17866, 19483, 21247, 23170, 25267, 27554, 30048
  293. };
  294.  
  295. static const uint32_t celt_pvq_u[1272] = {
  296.     /* N = 0, K = 0...176 */
  297.     1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  298.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  299.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  300.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  301.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  302.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  303.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  304.     /* N = 1, K = 1...176 */
  305.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  306.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  307.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  308.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  309.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  310.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  311.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  312.     /* N = 2, K = 2...176 */
  313.     3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41,
  314.     43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79,
  315.     81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113,
  316.     115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143,
  317.     145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173,
  318.     175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203,
  319.     205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233,
  320.     235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255, 257, 259, 261, 263,
  321.     265, 267, 269, 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, 291, 293,
  322.     295, 297, 299, 301, 303, 305, 307, 309, 311, 313, 315, 317, 319, 321, 323,
  323.     325, 327, 329, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349, 351,
  324.     /* N = 3, K = 3...176 */
  325.     13, 25, 41, 61, 85, 113, 145, 181, 221, 265, 313, 365, 421, 481, 545, 613,
  326.     685, 761, 841, 925, 1013, 1105, 1201, 1301, 1405, 1513, 1625, 1741, 1861,
  327.     1985, 2113, 2245, 2381, 2521, 2665, 2813, 2965, 3121, 3281, 3445, 3613, 3785,
  328.     3961, 4141, 4325, 4513, 4705, 4901, 5101, 5305, 5513, 5725, 5941, 6161, 6385,
  329.     6613, 6845, 7081, 7321, 7565, 7813, 8065, 8321, 8581, 8845, 9113, 9385, 9661,
  330.     9941, 10225, 10513, 10805, 11101, 11401, 11705, 12013, 12325, 12641, 12961,
  331.     13285, 13613, 13945, 14281, 14621, 14965, 15313, 15665, 16021, 16381, 16745,
  332.     17113, 17485, 17861, 18241, 18625, 19013, 19405, 19801, 20201, 20605, 21013,
  333.     21425, 21841, 22261, 22685, 23113, 23545, 23981, 24421, 24865, 25313, 25765,
  334.     26221, 26681, 27145, 27613, 28085, 28561, 29041, 29525, 30013, 30505, 31001,
  335.     31501, 32005, 32513, 33025, 33541, 34061, 34585, 35113, 35645, 36181, 36721,
  336.     37265, 37813, 38365, 38921, 39481, 40045, 40613, 41185, 41761, 42341, 42925,
  337.     43513, 44105, 44701, 45301, 45905, 46513, 47125, 47741, 48361, 48985, 49613,
  338.     50245, 50881, 51521, 52165, 52813, 53465, 54121, 54781, 55445, 56113, 56785,
  339.     57461, 58141, 58825, 59513, 60205, 60901, 61601,
  340.     /* N = 4, K = 4...176 */
  341.     63, 129, 231, 377, 575, 833, 1159, 1561, 2047, 2625, 3303, 4089, 4991, 6017,
  342.     7175, 8473, 9919, 11521, 13287, 15225, 17343, 19649, 22151, 24857, 27775,
  343.     30913, 34279, 37881, 41727, 45825, 50183, 54809, 59711, 64897, 70375, 76153,
  344.     82239, 88641, 95367, 102425, 109823, 117569, 125671, 134137, 142975, 152193,
  345.     161799, 171801, 182207, 193025, 204263, 215929, 228031, 240577, 253575,
  346.     267033, 280959, 295361, 310247, 325625, 341503, 357889, 374791, 392217,
  347.     410175, 428673, 447719, 467321, 487487, 508225, 529543, 551449, 573951,
  348.     597057, 620775, 645113, 670079, 695681, 721927, 748825, 776383, 804609,
  349.     833511, 863097, 893375, 924353, 956039, 988441, 1021567, 1055425, 1090023,
  350.     1125369, 1161471, 1198337, 1235975, 1274393, 1313599, 1353601, 1394407,
  351.     1436025, 1478463, 1521729, 1565831, 1610777, 1656575, 1703233, 1750759,
  352.     1799161, 1848447, 1898625, 1949703, 2001689, 2054591, 2108417, 2163175,
  353.     2218873, 2275519, 2333121, 2391687, 2451225, 2511743, 2573249, 2635751,
  354.     2699257, 2763775, 2829313, 2895879, 2963481, 3032127, 3101825, 3172583,
  355.     3244409, 3317311, 3391297, 3466375, 3542553, 3619839, 3698241, 3777767,
  356.     3858425, 3940223, 4023169, 4107271, 4192537, 4278975, 4366593, 4455399,
  357.     4545401, 4636607, 4729025, 4822663, 4917529, 5013631, 5110977, 5209575,
  358.     5309433, 5410559, 5512961, 5616647, 5721625, 5827903, 5935489, 6044391,
  359.     6154617, 6266175, 6379073, 6493319, 6608921, 6725887, 6844225, 6963943,
  360.     7085049, 7207551,
  361.     /* N = 5, K = 5...176 */
  362.     321, 681, 1289, 2241, 3649, 5641, 8361, 11969, 16641, 22569, 29961, 39041,
  363.     50049, 63241, 78889, 97281, 118721, 143529, 172041, 204609, 241601, 283401,
  364.     330409, 383041, 441729, 506921, 579081, 658689, 746241, 842249, 947241,
  365.     1061761, 1186369, 1321641, 1468169, 1626561, 1797441, 1981449, 2179241,
  366.     2391489, 2618881, 2862121, 3121929, 3399041, 3694209, 4008201, 4341801,
  367.     4695809, 5071041, 5468329, 5888521, 6332481, 6801089, 7295241, 7815849,
  368.     8363841, 8940161, 9545769, 10181641, 10848769, 11548161, 12280841, 13047849,
  369.     13850241, 14689089, 15565481, 16480521, 17435329, 18431041, 19468809,
  370.     20549801, 21675201, 22846209, 24064041, 25329929, 26645121, 28010881,
  371.     29428489, 30899241, 32424449, 34005441, 35643561, 37340169, 39096641,
  372.     40914369, 42794761, 44739241, 46749249, 48826241, 50971689, 53187081,
  373.     55473921, 57833729, 60268041, 62778409, 65366401, 68033601, 70781609,
  374.     73612041, 76526529, 79526721, 82614281, 85790889, 89058241, 92418049,
  375.     95872041, 99421961, 103069569, 106816641, 110664969, 114616361, 118672641,
  376.     122835649, 127107241, 131489289, 135983681, 140592321, 145317129, 150160041,
  377.     155123009, 160208001, 165417001, 170752009, 176215041, 181808129, 187533321,
  378.     193392681, 199388289, 205522241, 211796649, 218213641, 224775361, 231483969,
  379.     238341641, 245350569, 252512961, 259831041, 267307049, 274943241, 282741889,
  380.     290705281, 298835721, 307135529, 315607041, 324252609, 333074601, 342075401,
  381.     351257409, 360623041, 370174729, 379914921, 389846081, 399970689, 410291241,
  382.     420810249, 431530241, 442453761, 453583369, 464921641, 476471169, 488234561,
  383.     500214441, 512413449, 524834241, 537479489, 550351881, 563454121, 576788929,
  384.     590359041, 604167209, 618216201, 632508801,
  385.     /* N = 6, K = 6...96 (technically V(109,5) fits in 32 bits, but that can't be
  386.      achieved by splitting an Opus band) */
  387.     1683, 3653, 7183, 13073, 22363, 36365, 56695, 85305, 124515, 177045, 246047,
  388.     335137, 448427, 590557, 766727, 982729, 1244979, 1560549, 1937199, 2383409,
  389.     2908411, 3522221, 4235671, 5060441, 6009091, 7095093, 8332863, 9737793,
  390.     11326283, 13115773, 15124775, 17372905, 19880915, 22670725, 25765455,
  391.     29189457, 32968347, 37129037, 41699767, 46710137, 52191139, 58175189,
  392.     64696159, 71789409, 79491819, 87841821, 96879431, 106646281, 117185651,
  393.     128542501, 140763503, 153897073, 167993403, 183104493, 199284183, 216588185,
  394.     235074115, 254801525, 275831935, 298228865, 322057867, 347386557, 374284647,
  395.     402823977, 433078547, 465124549, 499040399, 534906769, 572806619, 612825229,
  396.     655050231, 699571641, 746481891, 795875861, 847850911, 902506913, 959946283,
  397.     1020274013, 1083597703, 1150027593, 1219676595, 1292660325, 1369097135,
  398.     1449108145, 1532817275, 1620351277, 1711839767, 1807415257, 1907213187,
  399.     2011371957, 2120032959,
  400.     /* N = 7, K = 7...54 (technically V(60,6) fits in 32 bits, but that can't be
  401.      achieved by splitting an Opus band) */
  402.     8989, 19825, 40081, 75517, 134245, 227305, 369305, 579125, 880685, 1303777,
  403.     1884961, 2668525, 3707509, 5064793, 6814249, 9041957, 11847485, 15345233,
  404.     19665841, 24957661, 31388293, 39146185, 48442297, 59511829, 72616013,
  405.     88043969, 106114625, 127178701, 151620757, 179861305, 212358985, 249612805,
  406.     292164445, 340600625, 395555537, 457713341, 527810725, 606639529, 695049433,
  407.     793950709, 904317037, 1027188385, 1163673953, 1314955181, 1482288821,
  408.     1667010073, 1870535785, 2094367717,
  409.     /* N = 8, K = 8...37 (technically V(40,7) fits in 32 bits, but that can't be
  410.      achieved by splitting an Opus band) */
  411.     48639, 108545, 224143, 433905, 795455, 1392065, 2340495, 3800305, 5984767,
  412.     9173505, 13726991, 20103025, 28875327, 40754369, 56610575, 77500017,
  413.     104692735, 139703809, 184327311, 240673265, 311207743, 398796225, 506750351,
  414.     638878193, 799538175, 993696769, 1226990095, 1505789553, 1837271615,
  415.     2229491905,
  416.     /* N = 9, K = 9...28 (technically V(29,8) fits in 32 bits, but that can't be
  417.      achieved by splitting an Opus band) */
  418.     265729, 598417, 1256465, 2485825, 4673345, 8405905, 14546705, 24331777,
  419.     39490049, 62390545, 96220561, 145198913, 214828609, 312193553, 446304145,
  420.     628496897, 872893441, 1196924561, 1621925137, 2173806145,
  421.     /* N = 10, K = 10...24 */
  422.     1462563, 3317445, 7059735, 14218905, 27298155, 50250765, 89129247, 152951073,
  423.     254831667, 413442773, 654862247, 1014889769, 1541911931, 2300409629,
  424.     3375210671,
  425.     /* N = 11, K = 11...19 (technically V(20,10) fits in 32 bits, but that can't be
  426.      achieved by splitting an Opus band) */
  427.     8097453, 18474633, 39753273, 81270333, 158819253, 298199265, 540279585,
  428.     948062325, 1616336765,
  429.     /* N = 12, K = 12...18 */
  430.     45046719, 103274625, 224298231, 464387817, 921406335, 1759885185,
  431.     3248227095,
  432.     /* N = 13, K = 13...16 */
  433.     251595969, 579168825, 1267854873, 2653649025,
  434.     /* N = 14, K = 14 */
  435.     1409933619
  436. };
  437.  
  438. DECLARE_ALIGNED(32, static const float, celt_window)[120] = {
  439.     6.7286966e-05f, 0.00060551348f, 0.0016815970f, 0.0032947962f, 0.0054439943f,
  440.     0.0081276923f, 0.011344001f, 0.015090633f, 0.019364886f, 0.024163635f,
  441.     0.029483315f, 0.035319905f, 0.041668911f, 0.048525347f, 0.055883718f,
  442.     0.063737999f, 0.072081616f, 0.080907428f, 0.090207705f, 0.099974111f,
  443.     0.11019769f, 0.12086883f, 0.13197729f, 0.14351214f, 0.15546177f,
  444.     0.16781389f, 0.18055550f, 0.19367290f, 0.20715171f, 0.22097682f,
  445.     0.23513243f, 0.24960208f, 0.26436860f, 0.27941419f, 0.29472040f,
  446.     0.31026818f, 0.32603788f, 0.34200931f, 0.35816177f, 0.37447407f,
  447.     0.39092462f, 0.40749142f, 0.42415215f, 0.44088423f, 0.45766484f,
  448.     0.47447104f, 0.49127978f, 0.50806798f, 0.52481261f, 0.54149077f,
  449.     0.55807973f, 0.57455701f, 0.59090049f, 0.60708841f, 0.62309951f,
  450.     0.63891306f, 0.65450896f, 0.66986776f, 0.68497077f, 0.69980010f,
  451.     0.71433873f, 0.72857055f, 0.74248043f, 0.75605424f, 0.76927895f,
  452.     0.78214257f, 0.79463430f, 0.80674445f, 0.81846456f, 0.82978733f,
  453.     0.84070669f, 0.85121779f, 0.86131698f, 0.87100183f, 0.88027111f,
  454.     0.88912479f, 0.89756398f, 0.90559094f, 0.91320904f, 0.92042270f,
  455.     0.92723738f, 0.93365955f, 0.93969656f, 0.94535671f, 0.95064907f,
  456.     0.95558353f, 0.96017067f, 0.96442171f, 0.96834849f, 0.97196334f,
  457.     0.97527906f, 0.97830883f, 0.98106616f, 0.98356480f, 0.98581869f,
  458.     0.98784191f, 0.98964856f, 0.99125274f, 0.99266849f, 0.99390969f,
  459.     0.99499004f, 0.99592297f, 0.99672162f, 0.99739874f, 0.99796667f,
  460.     0.99843728f, 0.99882195f, 0.99913147f, 0.99937606f, 0.99956527f,
  461.     0.99970802f, 0.99981248f, 0.99988613f, 0.99993565f, 0.99996697f,
  462.     0.99998518f, 0.99999457f, 0.99999859f, 0.99999982f, 1.0000000f,
  463. };
  464.  
  465. /* square of the window, used for the postfilter */
  466. const float ff_celt_window2[120] = {
  467.     4.5275357e-09f, 3.66647e-07f, 2.82777e-06f, 1.08557e-05f, 2.96371e-05f, 6.60594e-05f,
  468.     0.000128686f, 0.000227727f, 0.000374999f, 0.000583881f, 0.000869266f, 0.0012475f,
  469.     0.0017363f, 0.00235471f, 0.00312299f, 0.00406253f, 0.00519576f, 0.00654601f,
  470.     0.00813743f, 0.00999482f, 0.0121435f, 0.0146093f, 0.017418f, 0.0205957f, 0.0241684f,
  471.     0.0281615f, 0.0326003f, 0.0375092f, 0.0429118f, 0.0488308f, 0.0552873f, 0.0623012f,
  472.     0.0698908f, 0.0780723f, 0.0868601f, 0.0962664f, 0.106301f, 0.11697f, 0.12828f,
  473.     0.140231f, 0.152822f, 0.166049f, 0.179905f, 0.194379f, 0.209457f, 0.225123f, 0.241356f,
  474.     0.258133f, 0.275428f, 0.293212f, 0.311453f, 0.330116f, 0.349163f, 0.368556f, 0.388253f,
  475.     0.40821f, 0.428382f, 0.448723f, 0.469185f, 0.48972f, 0.51028f, 0.530815f, 0.551277f,
  476.     0.571618f, 0.59179f, 0.611747f, 0.631444f, 0.650837f, 0.669884f, 0.688547f, 0.706788f,
  477.     0.724572f, 0.741867f, 0.758644f, 0.774877f, 0.790543f, 0.805621f, 0.820095f, 0.833951f,
  478.     0.847178f, 0.859769f, 0.87172f, 0.88303f, 0.893699f, 0.903734f, 0.91314f, 0.921928f,
  479.     0.930109f, 0.937699f, 0.944713f, 0.951169f, 0.957088f, 0.962491f, 0.9674f, 0.971838f,
  480.     0.975832f, 0.979404f, 0.982582f, 0.985391f, 0.987857f, 0.990005f, 0.991863f, 0.993454f,
  481.     0.994804f, 0.995937f, 0.996877f, 0.997645f, 0.998264f, 0.998753f, 0.999131f, 0.999416f,
  482.     0.999625f, 0.999772f, 0.999871f, 0.999934f, 0.99997f, 0.999989f, 0.999997f, 0.99999964f, 1.0f,
  483. };
  484.  
  485. static const uint32_t * const celt_pvq_u_row[15] = {
  486.     celt_pvq_u +    0, celt_pvq_u +  176, celt_pvq_u +  351,
  487.     celt_pvq_u +  525, celt_pvq_u +  698, celt_pvq_u +  870,
  488.     celt_pvq_u + 1041, celt_pvq_u + 1131, celt_pvq_u + 1178,
  489.     celt_pvq_u + 1207, celt_pvq_u + 1226, celt_pvq_u + 1240,
  490.     celt_pvq_u + 1248, celt_pvq_u + 1254, celt_pvq_u + 1257
  491. };
  492.  
  493. static inline int16_t celt_cos(int16_t x)
  494. {
  495.     x = (MUL16(x, x) + 4096) >> 13;
  496.     x = (32767-x) + ROUND_MUL16(x, (-7651 + ROUND_MUL16(x, (8277 + ROUND_MUL16(-626, x)))));
  497.     return 1+x;
  498. }
  499.  
  500. static inline int celt_log2tan(int isin, int icos)
  501. {
  502.     int lc, ls;
  503.     lc = opus_ilog(icos);
  504.     ls = opus_ilog(isin);
  505.     icos <<= 15 - lc;
  506.     isin <<= 15 - ls;
  507.     return (ls << 11) - (lc << 11) +
  508.            ROUND_MUL16(isin, ROUND_MUL16(isin, -2597) + 7932) -
  509.            ROUND_MUL16(icos, ROUND_MUL16(icos, -2597) + 7932);
  510. }
  511.  
  512. static inline uint32_t celt_rng(CeltContext *s)
  513. {
  514.     s->seed = 1664525 * s->seed + 1013904223;
  515.     return s->seed;
  516. }
  517.  
  518. static void celt_decode_coarse_energy(CeltContext *s, OpusRangeCoder *rc)
  519. {
  520.     int i, j;
  521.     float prev[2] = {0};
  522.     float alpha, beta;
  523.     const uint8_t *model;
  524.  
  525.     /* use the 2D z-transform to apply prediction in both */
  526.     /* the time domain (alpha) and the frequency domain (beta) */
  527.  
  528.     if (opus_rc_tell(rc)+3 <= s->framebits && opus_rc_p2model(rc, 3)) {
  529.         /* intra frame */
  530.         alpha = 0;
  531.         beta  = 1.0f - 4915.0f/32768.0f;
  532.         model = celt_coarse_energy_dist[s->duration][1];
  533.     } else {
  534.         alpha = celt_alpha_coef[s->duration];
  535.         beta  = 1.0f - celt_beta_coef[s->duration];
  536.         model = celt_coarse_energy_dist[s->duration][0];
  537.     }
  538.  
  539.     for (i = 0; i < CELT_MAX_BANDS; i++) {
  540.         for (j = 0; j < s->coded_channels; j++) {
  541.             CeltFrame *frame = &s->frame[j];
  542.             float value;
  543.             int available;
  544.  
  545.             if (i < s->startband || i >= s->endband) {
  546.                 frame->energy[i] = 0.0;
  547.                 continue;
  548.             }
  549.  
  550.             available = s->framebits - opus_rc_tell(rc);
  551.             if (available >= 15) {
  552.                 /* decode using a Laplace distribution */
  553.                 int k = FFMIN(i, 20) << 1;
  554.                 value = opus_rc_laplace(rc, model[k] << 7, model[k+1] << 6);
  555.             } else if (available >= 2) {
  556.                 int x = opus_rc_getsymbol(rc, celt_model_energy_small);
  557.                 value = (x>>1) ^ -(x&1);
  558.             } else if (available >= 1) {
  559.                 value = -(float)opus_rc_p2model(rc, 1);
  560.             } else value = -1;
  561.  
  562.             frame->energy[i] = FFMAX(-9.0f, frame->energy[i]) * alpha + prev[j] + value;
  563.             prev[j] += beta * value;
  564.         }
  565.     }
  566. }
  567.  
  568. static void celt_decode_fine_energy(CeltContext *s, OpusRangeCoder *rc)
  569. {
  570.     int i;
  571.     for (i = s->startband; i < s->endband; i++) {
  572.         int j;
  573.         if (!s->fine_bits[i])
  574.             continue;
  575.  
  576.         for (j = 0; j < s->coded_channels; j++) {
  577.             CeltFrame *frame = &s->frame[j];
  578.             int q2;
  579.             float offset;
  580.             q2 = opus_getrawbits(rc, s->fine_bits[i]);
  581.             offset = (q2 + 0.5f) * (1 << (14 - s->fine_bits[i])) / 16384.0f - 0.5f;
  582.             frame->energy[i] += offset;
  583.         }
  584.     }
  585. }
  586.  
  587. static void celt_decode_final_energy(CeltContext *s, OpusRangeCoder *rc,
  588.                                      int bits_left)
  589. {
  590.     int priority, i, j;
  591.  
  592.     for (priority = 0; priority < 2; priority++) {
  593.         for (i = s->startband; i < s->endband && bits_left >= s->coded_channels; i++) {
  594.             if (s->fine_priority[i] != priority || s->fine_bits[i] >= CELT_MAX_FINE_BITS)
  595.                 continue;
  596.  
  597.             for (j = 0; j < s->coded_channels; j++) {
  598.                 int q2;
  599.                 float offset;
  600.                 q2 = opus_getrawbits(rc, 1);
  601.                 offset = (q2 - 0.5f) * (1 << (14 - s->fine_bits[i] - 1)) / 16384.0f;
  602.                 s->frame[j].energy[i] += offset;
  603.                 bits_left--;
  604.             }
  605.         }
  606.     }
  607. }
  608.  
  609. static void celt_decode_tf_changes(CeltContext *s, OpusRangeCoder *rc,
  610.                                    int transient)
  611. {
  612.     int i, diff = 0, tf_select = 0, tf_changed = 0, tf_select_bit;
  613.     int consumed, bits = transient ? 2 : 4;
  614.  
  615.     consumed = opus_rc_tell(rc);
  616.     tf_select_bit = (s->duration != 0 && consumed+bits+1 <= s->framebits);
  617.  
  618.     for (i = s->startband; i < s->endband; i++) {
  619.         if (consumed+bits+tf_select_bit <= s->framebits) {
  620.             diff ^= opus_rc_p2model(rc, bits);
  621.             consumed = opus_rc_tell(rc);
  622.             tf_changed |= diff;
  623.         }
  624.         s->tf_change[i] = diff;
  625.         bits = transient ? 4 : 5;
  626.     }
  627.  
  628.     if (tf_select_bit && celt_tf_select[s->duration][transient][0][tf_changed] !=
  629.                          celt_tf_select[s->duration][transient][1][tf_changed])
  630.         tf_select = opus_rc_p2model(rc, 1);
  631.  
  632.     for (i = s->startband; i < s->endband; i++) {
  633.         s->tf_change[i] = celt_tf_select[s->duration][transient][tf_select][s->tf_change[i]];
  634.     }
  635. }
  636.  
  637. static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
  638. {
  639.     // approx. maximum bit allocation for each band before boost/trim
  640.     int cap[CELT_MAX_BANDS];
  641.     int boost[CELT_MAX_BANDS];
  642.     int threshold[CELT_MAX_BANDS];
  643.     int bits1[CELT_MAX_BANDS];
  644.     int bits2[CELT_MAX_BANDS];
  645.     int trim_offset[CELT_MAX_BANDS];
  646.  
  647.     int skip_startband = s->startband;
  648.     int dynalloc       = 6;
  649.     int alloctrim      = 5;
  650.     int extrabits      = 0;
  651.  
  652.     int skip_bit            = 0;
  653.     int intensitystereo_bit = 0;
  654.     int dualstereo_bit      = 0;
  655.  
  656.     int remaining, bandbits;
  657.     int low, high, total, done;
  658.     int totalbits;
  659.     int consumed;
  660.     int i, j;
  661.  
  662.     consumed = opus_rc_tell(rc);
  663.  
  664.     /* obtain spread flag */
  665.     s->spread = CELT_SPREAD_NORMAL;
  666.     if (consumed + 4 <= s->framebits)
  667.         s->spread = opus_rc_getsymbol(rc, celt_model_spread);
  668.  
  669.     /* generate static allocation caps */
  670.     for (i = 0; i < CELT_MAX_BANDS; i++) {
  671.         cap[i] = (celt_static_caps[s->duration][s->coded_channels - 1][i] + 64)
  672.                  * celt_freq_range[i] << (s->coded_channels - 1) << s->duration >> 2;
  673.     }
  674.  
  675.     /* obtain band boost */
  676.     totalbits = s->framebits << 3; // convert to 1/8 bits
  677.     consumed = opus_rc_tell_frac(rc);
  678.     for (i = s->startband; i < s->endband; i++) {
  679.         int quanta, band_dynalloc;
  680.  
  681.         boost[i] = 0;
  682.  
  683.         quanta = celt_freq_range[i] << (s->coded_channels - 1) << s->duration;
  684.         quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta));
  685.         band_dynalloc = dynalloc;
  686.         while (consumed + (band_dynalloc<<3) < totalbits && boost[i] < cap[i]) {
  687.             int add = opus_rc_p2model(rc, band_dynalloc);
  688.             consumed = opus_rc_tell_frac(rc);
  689.             if (!add)
  690.                 break;
  691.  
  692.             boost[i]     += quanta;
  693.             totalbits    -= quanta;
  694.             band_dynalloc = 1;
  695.         }
  696.         /* dynalloc is more likely to occur if it's already been used for earlier bands */
  697.         if (boost[i])
  698.             dynalloc = FFMAX(2, dynalloc - 1);
  699.     }
  700.  
  701.     /* obtain allocation trim */
  702.     if (consumed + (6 << 3) <= totalbits)
  703.         alloctrim = opus_rc_getsymbol(rc, celt_model_alloc_trim);
  704.  
  705.     /* anti-collapse bit reservation */
  706.     totalbits = (s->framebits << 3) - opus_rc_tell_frac(rc) - 1;
  707.     s->anticollapse_bit = 0;
  708.     if (s->blocks > 1 && s->duration >= 2 &&
  709.         totalbits >= ((s->duration + 2) << 3))
  710.         s->anticollapse_bit = 1 << 3;
  711.     totalbits -= s->anticollapse_bit;
  712.  
  713.     /* band skip bit reservation */
  714.     if (totalbits >= 1 << 3)
  715.         skip_bit = 1 << 3;
  716.     totalbits -= skip_bit;
  717.  
  718.     /* intensity/dual stereo bit reservation */
  719.     if (s->coded_channels == 2) {
  720.         intensitystereo_bit = celt_log2_frac[s->endband - s->startband];
  721.         if (intensitystereo_bit <= totalbits) {
  722.             totalbits -= intensitystereo_bit;
  723.             if (totalbits >= 1 << 3) {
  724.                 dualstereo_bit = 1 << 3;
  725.                 totalbits -= 1 << 3;
  726.             }
  727.         } else
  728.             intensitystereo_bit = 0;
  729.     }
  730.  
  731.     for (i = s->startband; i < s->endband; i++) {
  732.         int trim     = alloctrim - 5 - s->duration;
  733.         int band     = celt_freq_range[i] * (s->endband - i - 1);
  734.         int duration = s->duration + 3;
  735.         int scale    = duration + s->coded_channels - 1;
  736.  
  737.         /* PVQ minimum allocation threshold, below this value the band is
  738.          * skipped */
  739.         threshold[i] = FFMAX(3 * celt_freq_range[i] << duration >> 4,
  740.                              s->coded_channels << 3);
  741.  
  742.         trim_offset[i] = trim * (band << scale) >> 6;
  743.  
  744.         if (celt_freq_range[i] << s->duration == 1)
  745.             trim_offset[i] -= s->coded_channels << 3;
  746.     }
  747.  
  748.     /* bisection */
  749.     low  = 1;
  750.     high = CELT_VECTORS - 1;
  751.     while (low <= high) {
  752.         int center = (low + high) >> 1;
  753.         done = total = 0;
  754.  
  755.         for (i = s->endband - 1; i >= s->startband; i--) {
  756.             bandbits = celt_freq_range[i] * celt_static_alloc[center][i]
  757.                        << (s->coded_channels - 1) << s->duration >> 2;
  758.  
  759.             if (bandbits)
  760.                 bandbits = FFMAX(0, bandbits + trim_offset[i]);
  761.             bandbits += boost[i];
  762.  
  763.             if (bandbits >= threshold[i] || done) {
  764.                 done = 1;
  765.                 total += FFMIN(bandbits, cap[i]);
  766.             } else if (bandbits >= s->coded_channels << 3)
  767.                 total += s->coded_channels << 3;
  768.         }
  769.  
  770.         if (total > totalbits)
  771.             high = center - 1;
  772.         else
  773.             low = center + 1;
  774.     }
  775.     high = low--;
  776.  
  777.     for (i = s->startband; i < s->endband; i++) {
  778.         bits1[i] = celt_freq_range[i] * celt_static_alloc[low][i]
  779.                    << (s->coded_channels - 1) << s->duration >> 2;
  780.         bits2[i] = high >= CELT_VECTORS ? cap[i] :
  781.                    celt_freq_range[i] * celt_static_alloc[high][i]
  782.                    << (s->coded_channels - 1) << s->duration >> 2;
  783.  
  784.         if (bits1[i])
  785.             bits1[i] = FFMAX(0, bits1[i] + trim_offset[i]);
  786.         if (bits2[i])
  787.             bits2[i] = FFMAX(0, bits2[i] + trim_offset[i]);
  788.         if (low)
  789.             bits1[i] += boost[i];
  790.         bits2[i] += boost[i];
  791.  
  792.         if (boost[i])
  793.             skip_startband = i;
  794.         bits2[i] = FFMAX(0, bits2[i] - bits1[i]);
  795.     }
  796.  
  797.     /* bisection */
  798.     low  = 0;
  799.     high = 1 << CELT_ALLOC_STEPS;
  800.     for (i = 0; i < CELT_ALLOC_STEPS; i++) {
  801.         int center = (low + high) >> 1;
  802.         done = total = 0;
  803.  
  804.         for (j = s->endband - 1; j >= s->startband; j--) {
  805.             bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS);
  806.  
  807.             if (bandbits >= threshold[j] || done) {
  808.                 done = 1;
  809.                 total += FFMIN(bandbits, cap[j]);
  810.             } else if (bandbits >= s->coded_channels << 3)
  811.                 total += s->coded_channels << 3;
  812.         }
  813.         if (total > totalbits)
  814.             high = center;
  815.         else
  816.             low = center;
  817.     }
  818.  
  819.     done = total = 0;
  820.     for (i = s->endband - 1; i >= s->startband; i--) {
  821.         bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS);
  822.  
  823.         if (bandbits >= threshold[i] || done)
  824.             done = 1;
  825.         else
  826.             bandbits = (bandbits >= s->coded_channels << 3) ?
  827.                        s->coded_channels << 3 : 0;
  828.  
  829.         bandbits     = FFMIN(bandbits, cap[i]);
  830.         s->pulses[i] = bandbits;
  831.         total      += bandbits;
  832.     }
  833.  
  834.     /* band skipping */
  835.     for (s->codedbands = s->endband; ; s->codedbands--) {
  836.         int allocation;
  837.         j = s->codedbands - 1;
  838.  
  839.         if (j == skip_startband) {
  840.             /* all remaining bands are not skipped */
  841.             totalbits += skip_bit;
  842.             break;
  843.         }
  844.  
  845.         /* determine the number of bits available for coding "do not skip" markers */
  846.         remaining   = totalbits - total;
  847.         bandbits    = remaining / (celt_freq_bands[j+1] - celt_freq_bands[s->startband]);
  848.         remaining  -= bandbits  * (celt_freq_bands[j+1] - celt_freq_bands[s->startband]);
  849.         allocation  = s->pulses[j] + bandbits * celt_freq_range[j]
  850.                       + FFMAX(0, remaining - (celt_freq_bands[j] - celt_freq_bands[s->startband]));
  851.  
  852.         /* a "do not skip" marker is only coded if the allocation is
  853.            above the chosen threshold */
  854.         if (allocation >= FFMAX(threshold[j], (s->coded_channels + 1) <<3 )) {
  855.             if (opus_rc_p2model(rc, 1))
  856.                 break;
  857.  
  858.             total      += 1 << 3;
  859.             allocation -= 1 << 3;
  860.         }
  861.  
  862.         /* the band is skipped, so reclaim its bits */
  863.         total -= s->pulses[j];
  864.         if (intensitystereo_bit) {
  865.             total -= intensitystereo_bit;
  866.             intensitystereo_bit = celt_log2_frac[j - s->startband];
  867.             total += intensitystereo_bit;
  868.         }
  869.  
  870.         total += s->pulses[j] = (allocation >= s->coded_channels << 3) ?
  871.                               s->coded_channels << 3 : 0;
  872.     }
  873.  
  874.     /* obtain stereo flags */
  875.     s->intensitystereo = 0;
  876.     s->dualstereo      = 0;
  877.     if (intensitystereo_bit)
  878.         s->intensitystereo = s->startband +
  879.                           opus_rc_unimodel(rc, s->codedbands + 1 - s->startband);
  880.     if (s->intensitystereo <= s->startband)
  881.         totalbits += dualstereo_bit; /* no intensity stereo means no dual stereo */
  882.     else if (dualstereo_bit)
  883.         s->dualstereo = opus_rc_p2model(rc, 1);
  884.  
  885.     /* supply the remaining bits in this frame to lower bands */
  886.     remaining = totalbits - total;
  887.     bandbits  = remaining / (celt_freq_bands[s->codedbands] - celt_freq_bands[s->startband]);
  888.     remaining -= bandbits * (celt_freq_bands[s->codedbands] - celt_freq_bands[s->startband]);
  889.     for (i = s->startband; i < s->codedbands; i++) {
  890.         int bits = FFMIN(remaining, celt_freq_range[i]);
  891.  
  892.         s->pulses[i] += bits + bandbits * celt_freq_range[i];
  893.         remaining    -= bits;
  894.     }
  895.  
  896.     for (i = s->startband; i < s->codedbands; i++) {
  897.         int N = celt_freq_range[i] << s->duration;
  898.         int prev_extra = extrabits;
  899.         s->pulses[i] += extrabits;
  900.  
  901.         if (N > 1) {
  902.             int dof;        // degrees of freedom
  903.             int temp;       // dof * channels * log(dof)
  904.             int offset;     // fine energy quantization offset, i.e.
  905.                             // extra bits assigned over the standard
  906.                             // totalbits/dof
  907.             int fine_bits, max_bits;
  908.  
  909.             extrabits = FFMAX(0, s->pulses[i] - cap[i]);
  910.             s->pulses[i] -= extrabits;
  911.  
  912.             /* intensity stereo makes use of an extra degree of freedom */
  913.             dof = N * s->coded_channels
  914.                   + (s->coded_channels == 2 && N > 2 && !s->dualstereo && i < s->intensitystereo);
  915.             temp = dof * (celt_log_freq_range[i] + (s->duration<<3));
  916.             offset = (temp >> 1) - dof * CELT_FINE_OFFSET;
  917.             if (N == 2) /* dof=2 is the only case that doesn't fit the model */
  918.                 offset += dof<<1;
  919.  
  920.             /* grant an additional bias for the first and second pulses */
  921.             if (s->pulses[i] + offset < 2 * (dof << 3))
  922.                 offset += temp >> 2;
  923.             else if (s->pulses[i] + offset < 3 * (dof << 3))
  924.                 offset += temp >> 3;
  925.  
  926.             fine_bits = (s->pulses[i] + offset + (dof << 2)) / (dof << 3);
  927.             max_bits  = FFMIN((s->pulses[i]>>3) >> (s->coded_channels - 1),
  928.                               CELT_MAX_FINE_BITS);
  929.  
  930.             max_bits  = FFMAX(max_bits, 0);
  931.  
  932.             s->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
  933.  
  934.             /* if fine_bits was rounded down or capped,
  935.                give priority for the final fine energy pass */
  936.             s->fine_priority[i] = (s->fine_bits[i] * (dof<<3) >= s->pulses[i] + offset);
  937.  
  938.             /* the remaining bits are assigned to PVQ */
  939.             s->pulses[i] -= s->fine_bits[i] << (s->coded_channels - 1) << 3;
  940.         } else {
  941.             /* all bits go to fine energy except for the sign bit */
  942.             extrabits = FFMAX(0, s->pulses[i] - (s->coded_channels << 3));
  943.             s->pulses[i] -= extrabits;
  944.             s->fine_bits[i] = 0;
  945.             s->fine_priority[i] = 1;
  946.         }
  947.  
  948.         /* hand back a limited number of extra fine energy bits to this band */
  949.         if (extrabits > 0) {
  950.             int fineextra = FFMIN(extrabits >> (s->coded_channels + 2),
  951.                                   CELT_MAX_FINE_BITS - s->fine_bits[i]);
  952.             s->fine_bits[i] += fineextra;
  953.  
  954.             fineextra <<= s->coded_channels + 2;
  955.             s->fine_priority[i] = (fineextra >= extrabits - prev_extra);
  956.             extrabits -= fineextra;
  957.         }
  958.     }
  959.     s->remaining = extrabits;
  960.  
  961.     /* skipped bands dedicate all of their bits for fine energy */
  962.     for (; i < s->endband; i++) {
  963.         s->fine_bits[i]     = s->pulses[i] >> (s->coded_channels - 1) >> 3;
  964.         s->pulses[i]        = 0;
  965.         s->fine_priority[i] = s->fine_bits[i] < 1;
  966.     }
  967. }
  968.  
  969. static inline int celt_bits2pulses(const uint8_t *cache, int bits)
  970. {
  971.     // TODO: Find the size of cache and make it into an array in the parameters list
  972.     int i, low = 0, high;
  973.  
  974.     high = cache[0];
  975.     bits--;
  976.  
  977.     for (i = 0; i < 6; i++) {
  978.         int center = (low + high + 1) >> 1;
  979.         if (cache[center] >= bits)
  980.             high = center;
  981.         else
  982.             low = center;
  983.     }
  984.  
  985.     return (bits - (low == 0 ? -1 : cache[low]) <= cache[high] - bits) ? low : high;
  986. }
  987.  
  988. static inline int celt_pulses2bits(const uint8_t *cache, int pulses)
  989. {
  990.     // TODO: Find the size of cache and make it into an array in the parameters list
  991.    return (pulses == 0) ? 0 : cache[pulses] + 1;
  992. }
  993.  
  994. static inline void celt_normalize_residual(const int * av_restrict iy, float * av_restrict X,
  995.                                            int N, float g)
  996. {
  997.     int i;
  998.     for (i = 0; i < N; i++)
  999.         X[i] = g * iy[i];
  1000. }
  1001.  
  1002. static void celt_exp_rotation1(float *X, unsigned int len, unsigned int stride,
  1003.                                float c, float s)
  1004. {
  1005.     float *Xptr;
  1006.     int i;
  1007.  
  1008.     Xptr = X;
  1009.     for (i = 0; i < len - stride; i++) {
  1010.         float x1, x2;
  1011.         x1           = Xptr[0];
  1012.         x2           = Xptr[stride];
  1013.         Xptr[stride] = c * x2 + s * x1;
  1014.         *Xptr++      = c * x1 - s * x2;
  1015.     }
  1016.  
  1017.     Xptr = &X[len - 2 * stride - 1];
  1018.     for (i = len - 2 * stride - 1; i >= 0; i--) {
  1019.         float x1, x2;
  1020.         x1           = Xptr[0];
  1021.         x2           = Xptr[stride];
  1022.         Xptr[stride] = c * x2 + s * x1;
  1023.         *Xptr--      = c * x1 - s * x2;
  1024.     }
  1025. }
  1026.  
  1027. static inline void celt_exp_rotation(float *X, unsigned int len,
  1028.                                      unsigned int stride, unsigned int K,
  1029.                                      enum CeltSpread spread)
  1030. {
  1031.     unsigned int stride2 = 0;
  1032.     float c, s;
  1033.     float gain, theta;
  1034.     int i;
  1035.  
  1036.     if (2*K >= len || spread == CELT_SPREAD_NONE)
  1037.         return;
  1038.  
  1039.     gain = (float)len / (len + (20 - 5*spread) * K);
  1040.     theta = M_PI * gain * gain / 4;
  1041.  
  1042.     c = cos(theta);
  1043.     s = sin(theta);
  1044.  
  1045.     if (len >= stride << 3) {
  1046.         stride2 = 1;
  1047.         /* This is just a simple (equivalent) way of computing sqrt(len/stride) with rounding.
  1048.         It's basically incrementing long as (stride2+0.5)^2 < len/stride. */
  1049.         while ((stride2 * stride2 + stride2) * stride + (stride >> 2) < len)
  1050.             stride2++;
  1051.     }
  1052.  
  1053.     /*NOTE: As a minor optimization, we could be passing around log2(B), not B, for both this and for
  1054.     extract_collapse_mask().*/
  1055.     len /= stride;
  1056.     for (i = 0; i < stride; i++) {
  1057.         if (stride2)
  1058.             celt_exp_rotation1(X + i * len, len, stride2, s, c);
  1059.         celt_exp_rotation1(X + i * len, len, 1, c, s);
  1060.     }
  1061. }
  1062.  
  1063. static inline unsigned int celt_extract_collapse_mask(const int *iy,
  1064.                                                       unsigned int N,
  1065.                                                       unsigned int B)
  1066. {
  1067.     unsigned int collapse_mask;
  1068.     int N0;
  1069.     int i, j;
  1070.  
  1071.     if (B <= 1)
  1072.         return 1;
  1073.  
  1074.     /*NOTE: As a minor optimization, we could be passing around log2(B), not B, for both this and for
  1075.     exp_rotation().*/
  1076.     N0 = N/B;
  1077.     collapse_mask = 0;
  1078.     for (i = 0; i < B; i++)
  1079.         for (j = 0; j < N0; j++)
  1080.             collapse_mask |= (iy[i*N0+j]!=0)<<i;
  1081.     return collapse_mask;
  1082. }
  1083.  
  1084. static inline void celt_renormalize_vector(float *X, int N, float gain)
  1085. {
  1086.     int i;
  1087.     float g = 1e-15f;
  1088.     for (i = 0; i < N; i++)
  1089.         g += X[i] * X[i];
  1090.     g = gain / sqrtf(g);
  1091.  
  1092.     for (i = 0; i < N; i++)
  1093.         X[i] *= g;
  1094. }
  1095.  
  1096. static inline void celt_stereo_merge(float *X, float *Y, float mid, int N)
  1097. {
  1098.     int i;
  1099.     float xp = 0, side = 0;
  1100.     float E[2];
  1101.     float mid2;
  1102.     float t, gain[2];
  1103.  
  1104.     /* Compute the norm of X+Y and X-Y as |X|^2 + |Y|^2 +/- sum(xy) */
  1105.     for (i = 0; i < N; i++) {
  1106.         xp   += X[i] * Y[i];
  1107.         side += Y[i] * Y[i];
  1108.     }
  1109.  
  1110.     /* Compensating for the mid normalization */
  1111.     xp *= mid;
  1112.     mid2 = mid;
  1113.     E[0] = mid2 * mid2 + side - 2 * xp;
  1114.     E[1] = mid2 * mid2 + side + 2 * xp;
  1115.     if (E[0] < 6e-4f || E[1] < 6e-4f) {
  1116.         for (i = 0; i < N; i++)
  1117.             Y[i] = X[i];
  1118.         return;
  1119.     }
  1120.  
  1121.     t = E[0];
  1122.     gain[0] = 1.0f / sqrtf(t);
  1123.     t = E[1];
  1124.     gain[1] = 1.0f / sqrtf(t);
  1125.  
  1126.     for (i = 0; i < N; i++) {
  1127.         float value[2];
  1128.         /* Apply mid scaling (side is already scaled) */
  1129.         value[0] = mid * X[i];
  1130.         value[1] = Y[i];
  1131.         X[i] = gain[0] * (value[0] - value[1]);
  1132.         Y[i] = gain[1] * (value[0] + value[1]);
  1133.     }
  1134. }
  1135.  
  1136. static void celt_interleave_hadamard(float *tmp, float *X, int N0,
  1137.                                      int stride, int hadamard)
  1138. {
  1139.     int i, j;
  1140.     int N = N0*stride;
  1141.  
  1142.     if (hadamard) {
  1143.         const uint8_t *ordery = celt_hadamard_ordery + stride - 2;
  1144.         for (i = 0; i < stride; i++)
  1145.             for (j = 0; j < N0; j++)
  1146.                 tmp[j*stride+i] = X[ordery[i]*N0+j];
  1147.     } else {
  1148.         for (i = 0; i < stride; i++)
  1149.             for (j = 0; j < N0; j++)
  1150.                 tmp[j*stride+i] = X[i*N0+j];
  1151.     }
  1152.  
  1153.     for (i = 0; i < N; i++)
  1154.         X[i] = tmp[i];
  1155. }
  1156.  
  1157. static void celt_deinterleave_hadamard(float *tmp, float *X, int N0,
  1158.                                        int stride, int hadamard)
  1159. {
  1160.     int i, j;
  1161.     int N = N0*stride;
  1162.  
  1163.     if (hadamard) {
  1164.         const uint8_t *ordery = celt_hadamard_ordery + stride - 2;
  1165.         for (i = 0; i < stride; i++)
  1166.             for (j = 0; j < N0; j++)
  1167.                 tmp[ordery[i]*N0+j] = X[j*stride+i];
  1168.     } else {
  1169.         for (i = 0; i < stride; i++)
  1170.             for (j = 0; j < N0; j++)
  1171.                 tmp[i*N0+j] = X[j*stride+i];
  1172.     }
  1173.  
  1174.     for (i = 0; i < N; i++)
  1175.         X[i] = tmp[i];
  1176. }
  1177.  
  1178. static void celt_haar1(float *X, int N0, int stride)
  1179. {
  1180.     int i, j;
  1181.     N0 >>= 1;
  1182.     for (i = 0; i < stride; i++) {
  1183.         for (j = 0; j < N0; j++) {
  1184.             float x0 = X[stride * (2 * j + 0) + i];
  1185.             float x1 = X[stride * (2 * j + 1) + i];
  1186.             X[stride * (2 * j + 0) + i] = (x0 + x1) * M_SQRT1_2;
  1187.             X[stride * (2 * j + 1) + i] = (x0 - x1) * M_SQRT1_2;
  1188.         }
  1189.     }
  1190. }
  1191.  
  1192. static inline int celt_compute_qn(int N, int b, int offset, int pulse_cap,
  1193.                                   int dualstereo)
  1194. {
  1195.     int qn, qb;
  1196.     int N2 = 2 * N - 1;
  1197.     if (dualstereo && N == 2)
  1198.         N2--;
  1199.  
  1200.     /* The upper limit ensures that in a stereo split with itheta==16384, we'll
  1201.      * always have enough bits left over to code at least one pulse in the
  1202.      * side; otherwise it would collapse, since it doesn't get folded. */
  1203.     qb = FFMIN3(b - pulse_cap - (4 << 3), (b + N2 * offset) / N2, 8 << 3);
  1204.     qn = (qb < (1 << 3 >> 1)) ? 1 : ((celt_qn_exp2[qb & 0x7] >> (14 - (qb >> 3))) + 1) >> 1 << 1;
  1205.     return qn;
  1206. }
  1207.  
  1208. // this code was adapted from libopus
  1209. static inline uint64_t celt_cwrsi(unsigned int N, unsigned int K, unsigned int i, int *y)
  1210. {
  1211.     uint64_t norm = 0;
  1212.     uint32_t p;
  1213.     int s, val;
  1214.     int k0;
  1215.  
  1216.     while (N > 2) {
  1217.         uint32_t q;
  1218.  
  1219.         /*Lots of pulses case:*/
  1220.         if (K >= N) {
  1221.             const uint32_t *row = celt_pvq_u_row[N];
  1222.  
  1223.             /* Are the pulses in this dimension negative? */
  1224.             p  = row[K + 1];
  1225.             s  = -(i >= p);
  1226.             i -= p & s;
  1227.  
  1228.             /*Count how many pulses were placed in this dimension.*/
  1229.             k0 = K;
  1230.             q = row[N];
  1231.             if (q > i) {
  1232.                 K = N;
  1233.                 do {
  1234.                     p = celt_pvq_u_row[--K][N];
  1235.                 } while (p > i);
  1236.             } else
  1237.                 for (p = row[K]; p > i; p = row[K])
  1238.                     K--;
  1239.  
  1240.             i    -= p;
  1241.             val   = (k0 - K + s) ^ s;
  1242.             norm += val * val;
  1243.             *y++  = val;
  1244.         } else { /*Lots of dimensions case:*/
  1245.             /*Are there any pulses in this dimension at all?*/
  1246.             p = celt_pvq_u_row[K    ][N];
  1247.             q = celt_pvq_u_row[K + 1][N];
  1248.  
  1249.             if (p <= i && i < q) {
  1250.                 i -= p;
  1251.                 *y++ = 0;
  1252.             } else {
  1253.                 /*Are the pulses in this dimension negative?*/
  1254.                 s  = -(i >= q);
  1255.                 i -= q & s;
  1256.  
  1257.                 /*Count how many pulses were placed in this dimension.*/
  1258.                 k0 = K;
  1259.                 do p = celt_pvq_u_row[--K][N];
  1260.                 while (p > i);
  1261.  
  1262.                 i    -= p;
  1263.                 val   = (k0 - K + s) ^ s;
  1264.                 norm += val * val;
  1265.                 *y++  = val;
  1266.             }
  1267.         }
  1268.         N--;
  1269.     }
  1270.  
  1271.     /* N == 2 */
  1272.     p  = 2 * K + 1;
  1273.     s  = -(i >= p);
  1274.     i -= p & s;
  1275.     k0 = K;
  1276.     K  = (i + 1) / 2;
  1277.  
  1278.     if (K)
  1279.         i -= 2 * K - 1;
  1280.  
  1281.     val   = (k0 - K + s) ^ s;
  1282.     norm += val * val;
  1283.     *y++  = val;
  1284.  
  1285.     /* N==1 */
  1286.     s     = -i;
  1287.     val   = (K + s) ^ s;
  1288.     norm += val * val;
  1289.     *y    = val;
  1290.  
  1291.     return norm;
  1292. }
  1293.  
  1294. static inline float celt_decode_pulses(OpusRangeCoder *rc, int *y, unsigned int N, unsigned int K)
  1295. {
  1296.     unsigned int idx;
  1297. #define CELT_PVQ_U(n, k) (celt_pvq_u_row[FFMIN(n, k)][FFMAX(n, k)])
  1298. #define CELT_PVQ_V(n, k) (CELT_PVQ_U(n, k) + CELT_PVQ_U(n, (k) + 1))
  1299.     idx = opus_rc_unimodel(rc, CELT_PVQ_V(N, K));
  1300.     return celt_cwrsi(N, K, idx, y);
  1301. }
  1302.  
  1303. /** Decode pulse vector and combine the result with the pitch vector to produce
  1304.     the final normalised signal in the current band. */
  1305. static inline unsigned int celt_alg_unquant(OpusRangeCoder *rc, float *X,
  1306.                                             unsigned int N, unsigned int K,
  1307.                                             enum CeltSpread spread,
  1308.                                             unsigned int blocks, float gain)
  1309. {
  1310.     int y[176];
  1311.  
  1312.     gain /= sqrtf(celt_decode_pulses(rc, y, N, K));
  1313.     celt_normalize_residual(y, X, N, gain);
  1314.     celt_exp_rotation(X, N, blocks, K, spread);
  1315.     return celt_extract_collapse_mask(y, N, blocks);
  1316. }
  1317.  
  1318. static unsigned int celt_decode_band(CeltContext *s, OpusRangeCoder *rc,
  1319.                                      const int band, float *X, float *Y,
  1320.                                      int N, int b, unsigned int blocks,
  1321.                                      float *lowband, int duration,
  1322.                                      float *lowband_out, int level,
  1323.                                      float gain, float *lowband_scratch,
  1324.                                      int fill)
  1325. {
  1326.     const uint8_t *cache;
  1327.     int dualstereo, split;
  1328.     int imid = 0, iside = 0;
  1329.     unsigned int N0 = N;
  1330.     int N_B;
  1331.     int N_B0;
  1332.     int B0 = blocks;
  1333.     int time_divide = 0;
  1334.     int recombine = 0;
  1335.     int inv = 0;
  1336.     float mid = 0, side = 0;
  1337.     int longblocks = (B0 == 1);
  1338.     unsigned int cm = 0;
  1339.  
  1340.     N_B0 = N_B = N / blocks;
  1341.     split = dualstereo = (Y != NULL);
  1342.  
  1343.     if (N == 1) {
  1344.         /* special case for one sample */
  1345.         int i;
  1346.         float *x = X;
  1347.         for (i = 0; i <= dualstereo; i++) {
  1348.             int sign = 0;
  1349.             if (s->remaining2 >= 1<<3) {
  1350.                 sign           = opus_getrawbits(rc, 1);
  1351.                 s->remaining2 -= 1 << 3;
  1352.                 b             -= 1 << 3;
  1353.             }
  1354.             x[0] = sign ? -1.0f : 1.0f;
  1355.             x = Y;
  1356.         }
  1357.         if (lowband_out)
  1358.             lowband_out[0] = X[0];
  1359.         return 1;
  1360.     }
  1361.  
  1362.     if (!dualstereo && level == 0) {
  1363.         int tf_change = s->tf_change[band];
  1364.         int k;
  1365.         if (tf_change > 0)
  1366.             recombine = tf_change;
  1367.         /* Band recombining to increase frequency resolution */
  1368.  
  1369.         if (lowband &&
  1370.             (recombine || ((N_B & 1) == 0 && tf_change < 0) || B0 > 1)) {
  1371.             int j;
  1372.             for (j = 0; j < N; j++)
  1373.                 lowband_scratch[j] = lowband[j];
  1374.             lowband = lowband_scratch;
  1375.         }
  1376.  
  1377.         for (k = 0; k < recombine; k++) {
  1378.             if (lowband)
  1379.                 celt_haar1(lowband, N >> k, 1 << k);
  1380.             fill = celt_bit_interleave[fill & 0xF] | celt_bit_interleave[fill >> 4] << 2;
  1381.         }
  1382.         blocks >>= recombine;
  1383.         N_B <<= recombine;
  1384.  
  1385.         /* Increasing the time resolution */
  1386.         while ((N_B & 1) == 0 && tf_change < 0) {
  1387.             if (lowband)
  1388.                 celt_haar1(lowband, N_B, blocks);
  1389.             fill |= fill << blocks;
  1390.             blocks <<= 1;
  1391.             N_B >>= 1;
  1392.             time_divide++;
  1393.             tf_change++;
  1394.         }
  1395.         B0 = blocks;
  1396.         N_B0 = N_B;
  1397.  
  1398.         /* Reorganize the samples in time order instead of frequency order */
  1399.         if (B0 > 1 && lowband)
  1400.             celt_deinterleave_hadamard(s->scratch, lowband, N_B >> recombine,
  1401.                                        B0 << recombine, longblocks);
  1402.     }
  1403.  
  1404.     /* If we need 1.5 more bit than we can produce, split the band in two. */
  1405.     cache = celt_cache_bits +
  1406.             celt_cache_index[(duration + 1) * CELT_MAX_BANDS + band];
  1407.     if (!dualstereo && duration >= 0 && b > cache[cache[0]] + 12 && N > 2) {
  1408.         N >>= 1;
  1409.         Y = X + N;
  1410.         split = 1;
  1411.         duration -= 1;
  1412.         if (blocks == 1)
  1413.             fill = (fill & 1) | (fill << 1);
  1414.         blocks = (blocks + 1) >> 1;
  1415.     }
  1416.  
  1417.     if (split) {
  1418.         int qn;
  1419.         int itheta = 0;
  1420.         int mbits, sbits, delta;
  1421.         int qalloc;
  1422.         int pulse_cap;
  1423.         int offset;
  1424.         int orig_fill;
  1425.         int tell;
  1426.  
  1427.         /* Decide on the resolution to give to the split parameter theta */
  1428.         pulse_cap = celt_log_freq_range[band] + duration * 8;
  1429.         offset = (pulse_cap >> 1) - (dualstereo && N == 2 ? CELT_QTHETA_OFFSET_TWOPHASE :
  1430.                                                           CELT_QTHETA_OFFSET);
  1431.         qn = (dualstereo && band >= s->intensitystereo) ? 1 :
  1432.              celt_compute_qn(N, b, offset, pulse_cap, dualstereo);
  1433.         tell = opus_rc_tell_frac(rc);
  1434.         if (qn != 1) {
  1435.             /* Entropy coding of the angle. We use a uniform pdf for the
  1436.             time split, a step for stereo, and a triangular one for the rest. */
  1437.             if (dualstereo && N > 2)
  1438.                 itheta = opus_rc_stepmodel(rc, qn/2);
  1439.             else if (dualstereo || B0 > 1)
  1440.                 itheta = opus_rc_unimodel(rc, qn+1);
  1441.             else
  1442.                 itheta = opus_rc_trimodel(rc, qn);
  1443.             itheta = itheta * 16384 / qn;
  1444.             /* NOTE: Renormalising X and Y *may* help fixed-point a bit at very high rate.
  1445.             Let's do that at higher complexity */
  1446.         } else if (dualstereo) {
  1447.             inv = (b > 2 << 3 && s->remaining2 > 2 << 3) ? opus_rc_p2model(rc, 2) : 0;
  1448.             itheta = 0;
  1449.         }
  1450.         qalloc = opus_rc_tell_frac(rc) - tell;
  1451.         b -= qalloc;
  1452.  
  1453.         orig_fill = fill;
  1454.         if (itheta == 0) {
  1455.             imid = 32767;
  1456.             iside = 0;
  1457.             fill = av_mod_uintp2(fill, blocks);
  1458.             delta = -16384;
  1459.         } else if (itheta == 16384) {
  1460.             imid = 0;
  1461.             iside = 32767;
  1462.             fill &= ((1 << blocks) - 1) << blocks;
  1463.             delta = 16384;
  1464.         } else {
  1465.             imid = celt_cos(itheta);
  1466.             iside = celt_cos(16384-itheta);
  1467.             /* This is the mid vs side allocation that minimizes squared error
  1468.             in that band. */
  1469.             delta = ROUND_MUL16((N - 1) << 7, celt_log2tan(iside, imid));
  1470.         }
  1471.  
  1472.         mid  = imid  / 32768.0f;
  1473.         side = iside / 32768.0f;
  1474.  
  1475.         /* This is a special case for N=2 that only works for stereo and takes
  1476.         advantage of the fact that mid and side are orthogonal to encode
  1477.         the side with just one bit. */
  1478.         if (N == 2 && dualstereo) {
  1479.             int c;
  1480.             int sign = 0;
  1481.             float tmp;
  1482.             float *x2, *y2;
  1483.             mbits = b;
  1484.             /* Only need one bit for the side */
  1485.             sbits = (itheta != 0 && itheta != 16384) ? 1 << 3 : 0;
  1486.             mbits -= sbits;
  1487.             c = (itheta > 8192);
  1488.             s->remaining2 -= qalloc+sbits;
  1489.  
  1490.             x2 = c ? Y : X;
  1491.             y2 = c ? X : Y;
  1492.             if (sbits)
  1493.                 sign = opus_getrawbits(rc, 1);
  1494.             sign = 1 - 2 * sign;
  1495.             /* We use orig_fill here because we want to fold the side, but if
  1496.             itheta==16384, we'll have cleared the low bits of fill. */
  1497.             cm = celt_decode_band(s, rc, band, x2, NULL, N, mbits, blocks,
  1498.                                   lowband, duration, lowband_out, level, gain,
  1499.                                   lowband_scratch, orig_fill);
  1500.             /* We don't split N=2 bands, so cm is either 1 or 0 (for a fold-collapse),
  1501.             and there's no need to worry about mixing with the other channel. */
  1502.             y2[0] = -sign * x2[1];
  1503.             y2[1] =  sign * x2[0];
  1504.             X[0] *= mid;
  1505.             X[1] *= mid;
  1506.             Y[0] *= side;
  1507.             Y[1] *= side;
  1508.             tmp = X[0];
  1509.             X[0] = tmp - Y[0];
  1510.             Y[0] = tmp + Y[0];
  1511.             tmp = X[1];
  1512.             X[1] = tmp - Y[1];
  1513.             Y[1] = tmp + Y[1];
  1514.         } else {
  1515.             /* "Normal" split code */
  1516.             float *next_lowband2     = NULL;
  1517.             float *next_lowband_out1 = NULL;
  1518.             int next_level = 0;
  1519.             int rebalance;
  1520.  
  1521.             /* Give more bits to low-energy MDCTs than they would
  1522.              * otherwise deserve */
  1523.             if (B0 > 1 && !dualstereo && (itheta & 0x3fff)) {
  1524.                 if (itheta > 8192)
  1525.                     /* Rough approximation for pre-echo masking */
  1526.                     delta -= delta >> (4 - duration);
  1527.                 else
  1528.                     /* Corresponds to a forward-masking slope of
  1529.                      * 1.5 dB per 10 ms */
  1530.                     delta = FFMIN(0, delta + (N << 3 >> (5 - duration)));
  1531.             }
  1532.             mbits = av_clip((b - delta) / 2, 0, b);
  1533.             sbits = b - mbits;
  1534.             s->remaining2 -= qalloc;
  1535.  
  1536.             if (lowband && !dualstereo)
  1537.                 next_lowband2 = lowband + N; /* >32-bit split case */
  1538.  
  1539.             /* Only stereo needs to pass on lowband_out.
  1540.              * Otherwise, it's handled at the end */
  1541.             if (dualstereo)
  1542.                 next_lowband_out1 = lowband_out;
  1543.             else
  1544.                 next_level = level + 1;
  1545.  
  1546.             rebalance = s->remaining2;
  1547.             if (mbits >= sbits) {
  1548.                 /* In stereo mode, we do not apply a scaling to the mid
  1549.                  * because we need the normalized mid for folding later */
  1550.                 cm = celt_decode_band(s, rc, band, X, NULL, N, mbits, blocks,
  1551.                                       lowband, duration, next_lowband_out1,
  1552.                                       next_level, dualstereo ? 1.0f : (gain * mid),
  1553.                                       lowband_scratch, fill);
  1554.  
  1555.                 rebalance = mbits - (rebalance - s->remaining2);
  1556.                 if (rebalance > 3 << 3 && itheta != 0)
  1557.                     sbits += rebalance - (3 << 3);
  1558.  
  1559.                 /* For a stereo split, the high bits of fill are always zero,
  1560.                  * so no folding will be done to the side. */
  1561.                 cm |= celt_decode_band(s, rc, band, Y, NULL, N, sbits, blocks,
  1562.                                        next_lowband2, duration, NULL,
  1563.                                        next_level, gain * side, NULL,
  1564.                                        fill >> blocks) << ((B0 >> 1) & (dualstereo - 1));
  1565.             } else {
  1566.                 /* For a stereo split, the high bits of fill are always zero,
  1567.                  * so no folding will be done to the side. */
  1568.                 cm = celt_decode_band(s, rc, band, Y, NULL, N, sbits, blocks,
  1569.                                       next_lowband2, duration, NULL,
  1570.                                       next_level, gain * side, NULL,
  1571.                                       fill >> blocks) << ((B0 >> 1) & (dualstereo - 1));
  1572.  
  1573.                 rebalance = sbits - (rebalance - s->remaining2);
  1574.                 if (rebalance > 3 << 3 && itheta != 16384)
  1575.                     mbits += rebalance - (3 << 3);
  1576.  
  1577.                 /* In stereo mode, we do not apply a scaling to the mid because
  1578.                  * we need the normalized mid for folding later */
  1579.                 cm |= celt_decode_band(s, rc, band, X, NULL, N, mbits, blocks,
  1580.                                        lowband, duration, next_lowband_out1,
  1581.                                        next_level, dualstereo ? 1.0f : (gain * mid),
  1582.                                        lowband_scratch, fill);
  1583.             }
  1584.         }
  1585.     } else {
  1586.         /* This is the basic no-split case */
  1587.         unsigned int q         = celt_bits2pulses(cache, b);
  1588.         unsigned int curr_bits = celt_pulses2bits(cache, q);
  1589.         s->remaining2 -= curr_bits;
  1590.  
  1591.         /* Ensures we can never bust the budget */
  1592.         while (s->remaining2 < 0 && q > 0) {
  1593.             s->remaining2 += curr_bits;
  1594.             curr_bits      = celt_pulses2bits(cache, --q);
  1595.             s->remaining2 -= curr_bits;
  1596.         }
  1597.  
  1598.         if (q != 0) {
  1599.             /* Finally do the actual quantization */
  1600.             cm = celt_alg_unquant(rc, X, N, (q < 8) ? q : (8 + (q & 7)) << ((q >> 3) - 1),
  1601.                                   s->spread, blocks, gain);
  1602.         } else {
  1603.             /* If there's no pulse, fill the band anyway */
  1604.             int j;
  1605.             unsigned int cm_mask = (1 << blocks) - 1;
  1606.             fill &= cm_mask;
  1607.             if (!fill) {
  1608.                 for (j = 0; j < N; j++)
  1609.                     X[j] = 0.0f;
  1610.             } else {
  1611.                 if (!lowband) {
  1612.                     /* Noise */
  1613.                     for (j = 0; j < N; j++)
  1614.                         X[j] = (((int32_t)celt_rng(s)) >> 20);
  1615.                     cm = cm_mask;
  1616.                 } else {
  1617.                     /* Folded spectrum */
  1618.                     for (j = 0; j < N; j++) {
  1619.                         /* About 48 dB below the "normal" folding level */
  1620.                         X[j] = lowband[j] + (((celt_rng(s)) & 0x8000) ? 1.0f / 256 : -1.0f / 256);
  1621.                     }
  1622.                     cm = fill;
  1623.                 }
  1624.                 celt_renormalize_vector(X, N, gain);
  1625.             }
  1626.         }
  1627.     }
  1628.  
  1629.     /* This code is used by the decoder and by the resynthesis-enabled encoder */
  1630.     if (dualstereo) {
  1631.         int j;
  1632.         if (N != 2)
  1633.             celt_stereo_merge(X, Y, mid, N);
  1634.         if (inv) {
  1635.             for (j = 0; j < N; j++)
  1636.                 Y[j] *= -1;
  1637.         }
  1638.     } else if (level == 0) {
  1639.         int k;
  1640.  
  1641.         /* Undo the sample reorganization going from time order to frequency order */
  1642.         if (B0 > 1)
  1643.             celt_interleave_hadamard(s->scratch, X, N_B>>recombine,
  1644.                                      B0<<recombine, longblocks);
  1645.  
  1646.         /* Undo time-freq changes that we did earlier */
  1647.         N_B = N_B0;
  1648.         blocks = B0;
  1649.         for (k = 0; k < time_divide; k++) {
  1650.             blocks >>= 1;
  1651.             N_B <<= 1;
  1652.             cm |= cm >> blocks;
  1653.             celt_haar1(X, N_B, blocks);
  1654.         }
  1655.  
  1656.         for (k = 0; k < recombine; k++) {
  1657.             cm = celt_bit_deinterleave[cm];
  1658.             celt_haar1(X, N0>>k, 1<<k);
  1659.         }
  1660.         blocks <<= recombine;
  1661.  
  1662.         /* Scale output for later folding */
  1663.         if (lowband_out) {
  1664.             int j;
  1665.             float n = sqrtf(N0);
  1666.             for (j = 0; j < N0; j++)
  1667.                 lowband_out[j] = n * X[j];
  1668.         }
  1669.         cm = av_mod_uintp2(cm, blocks);
  1670.     }
  1671.     return cm;
  1672. }
  1673.  
  1674. static void celt_denormalize(CeltContext *s, CeltFrame *frame, float *data)
  1675. {
  1676.     int i, j;
  1677.  
  1678.     for (i = s->startband; i < s->endband; i++) {
  1679.         float *dst = data + (celt_freq_bands[i] << s->duration);
  1680.         float norm = pow(2, frame->energy[i] + celt_mean_energy[i]);
  1681.  
  1682.         for (j = 0; j < celt_freq_range[i] << s->duration; j++)
  1683.             dst[j] *= norm;
  1684.     }
  1685. }
  1686.  
  1687. static void celt_postfilter_apply_transition(CeltFrame *frame, float *data)
  1688. {
  1689.     const int T0 = frame->pf_period_old;
  1690.     const int T1 = frame->pf_period;
  1691.  
  1692.     float g00, g01, g02;
  1693.     float g10, g11, g12;
  1694.  
  1695.     float x0, x1, x2, x3, x4;
  1696.  
  1697.     int i;
  1698.  
  1699.     if (frame->pf_gains[0]     == 0.0 &&
  1700.         frame->pf_gains_old[0] == 0.0)
  1701.         return;
  1702.  
  1703.     g00 = frame->pf_gains_old[0];
  1704.     g01 = frame->pf_gains_old[1];
  1705.     g02 = frame->pf_gains_old[2];
  1706.     g10 = frame->pf_gains[0];
  1707.     g11 = frame->pf_gains[1];
  1708.     g12 = frame->pf_gains[2];
  1709.  
  1710.     x1 = data[-T1 + 1];
  1711.     x2 = data[-T1];
  1712.     x3 = data[-T1 - 1];
  1713.     x4 = data[-T1 - 2];
  1714.  
  1715.     for (i = 0; i < CELT_OVERLAP; i++) {
  1716.         float w = ff_celt_window2[i];
  1717.         x0 = data[i - T1 + 2];
  1718.  
  1719.         data[i] +=  (1.0 - w) * g00 * data[i - T0]                          +
  1720.                     (1.0 - w) * g01 * (data[i - T0 - 1] + data[i - T0 + 1]) +
  1721.                     (1.0 - w) * g02 * (data[i - T0 - 2] + data[i - T0 + 2]) +
  1722.                     w         * g10 * x2                                    +
  1723.                     w         * g11 * (x1 + x3)                             +
  1724.                     w         * g12 * (x0 + x4);
  1725.         x4 = x3;
  1726.         x3 = x2;
  1727.         x2 = x1;
  1728.         x1 = x0;
  1729.     }
  1730. }
  1731.  
  1732. static void celt_postfilter_apply(CeltFrame *frame,
  1733.                                   float *data, int len)
  1734. {
  1735.     const int T = frame->pf_period;
  1736.     float g0, g1, g2;
  1737.     float x0, x1, x2, x3, x4;
  1738.     int i;
  1739.  
  1740.     if (frame->pf_gains[0] == 0.0 || len <= 0)
  1741.         return;
  1742.  
  1743.     g0 = frame->pf_gains[0];
  1744.     g1 = frame->pf_gains[1];
  1745.     g2 = frame->pf_gains[2];
  1746.  
  1747.     x4 = data[-T - 2];
  1748.     x3 = data[-T - 1];
  1749.     x2 = data[-T];
  1750.     x1 = data[-T + 1];
  1751.  
  1752.     for (i = 0; i < len; i++) {
  1753.         x0 = data[i - T + 2];
  1754.         data[i] += g0 * x2        +
  1755.                    g1 * (x1 + x3) +
  1756.                    g2 * (x0 + x4);
  1757.         x4 = x3;
  1758.         x3 = x2;
  1759.         x2 = x1;
  1760.         x1 = x0;
  1761.     }
  1762. }
  1763.  
  1764. static void celt_postfilter(CeltContext *s, CeltFrame *frame)
  1765. {
  1766.     int len = s->blocksize * s->blocks;
  1767.  
  1768.     celt_postfilter_apply_transition(frame, frame->buf + 1024);
  1769.  
  1770.     frame->pf_period_old = frame->pf_period;
  1771.     memcpy(frame->pf_gains_old, frame->pf_gains, sizeof(frame->pf_gains));
  1772.  
  1773.     frame->pf_period = frame->pf_period_new;
  1774.     memcpy(frame->pf_gains, frame->pf_gains_new, sizeof(frame->pf_gains));
  1775.  
  1776.     if (len > CELT_OVERLAP) {
  1777.         celt_postfilter_apply_transition(frame, frame->buf + 1024 + CELT_OVERLAP);
  1778.         celt_postfilter_apply(frame, frame->buf + 1024 + 2 * CELT_OVERLAP,
  1779.                               len - 2 * CELT_OVERLAP);
  1780.  
  1781.         frame->pf_period_old = frame->pf_period;
  1782.         memcpy(frame->pf_gains_old, frame->pf_gains, sizeof(frame->pf_gains));
  1783.     }
  1784.  
  1785.     memmove(frame->buf, frame->buf + len, (1024 + CELT_OVERLAP / 2) * sizeof(float));
  1786. }
  1787.  
  1788. static int parse_postfilter(CeltContext *s, OpusRangeCoder *rc, int consumed)
  1789. {
  1790.     static const float postfilter_taps[3][3] = {
  1791.         { 0.3066406250f, 0.2170410156f, 0.1296386719f },
  1792.         { 0.4638671875f, 0.2680664062f, 0.0           },
  1793.         { 0.7998046875f, 0.1000976562f, 0.0           }
  1794.     };
  1795.     int i;
  1796.  
  1797.     memset(s->frame[0].pf_gains_new, 0, sizeof(s->frame[0].pf_gains_new));
  1798.     memset(s->frame[1].pf_gains_new, 0, sizeof(s->frame[1].pf_gains_new));
  1799.  
  1800.     if (s->startband == 0 && consumed + 16 <= s->framebits) {
  1801.         int has_postfilter = opus_rc_p2model(rc, 1);
  1802.         if (has_postfilter) {
  1803.             float gain;
  1804.             int tapset, octave, period;
  1805.  
  1806.             octave = opus_rc_unimodel(rc, 6);
  1807.             period = (16 << octave) + opus_getrawbits(rc, 4 + octave) - 1;
  1808.             gain   = 0.09375f * (opus_getrawbits(rc, 3) + 1);
  1809.             tapset = (opus_rc_tell(rc) + 2 <= s->framebits) ?
  1810.                      opus_rc_getsymbol(rc, celt_model_tapset) : 0;
  1811.  
  1812.             for (i = 0; i < 2; i++) {
  1813.                 CeltFrame *frame = &s->frame[i];
  1814.  
  1815.                 frame->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
  1816.                 frame->pf_gains_new[0] = gain * postfilter_taps[tapset][0];
  1817.                 frame->pf_gains_new[1] = gain * postfilter_taps[tapset][1];
  1818.                 frame->pf_gains_new[2] = gain * postfilter_taps[tapset][2];
  1819.             }
  1820.         }
  1821.  
  1822.         consumed = opus_rc_tell(rc);
  1823.     }
  1824.  
  1825.     return consumed;
  1826. }
  1827.  
  1828. static void process_anticollapse(CeltContext *s, CeltFrame *frame, float *X)
  1829. {
  1830.     int i, j, k;
  1831.  
  1832.     for (i = s->startband; i < s->endband; i++) {
  1833.         int renormalize = 0;
  1834.         float *xptr;
  1835.         float prev[2];
  1836.         float Ediff, r;
  1837.         float thresh, sqrt_1;
  1838.         int depth;
  1839.  
  1840.         /* depth in 1/8 bits */
  1841.         depth = (1 + s->pulses[i]) / (celt_freq_range[i] << s->duration);
  1842.         thresh = pow(2, -1.0 - 0.125f * depth);
  1843.         sqrt_1 = 1.0f / sqrtf(celt_freq_range[i] << s->duration);
  1844.  
  1845.         xptr = X + (celt_freq_bands[i] << s->duration);
  1846.  
  1847.         prev[0] = frame->prev_energy[0][i];
  1848.         prev[1] = frame->prev_energy[1][i];
  1849.         if (s->coded_channels == 1) {
  1850.             CeltFrame *frame1 = &s->frame[1];
  1851.  
  1852.             prev[0] = FFMAX(prev[0], frame1->prev_energy[0][i]);
  1853.             prev[1] = FFMAX(prev[1], frame1->prev_energy[1][i]);
  1854.         }
  1855.         Ediff = frame->energy[i] - FFMIN(prev[0], prev[1]);
  1856.         Ediff = FFMAX(0, Ediff);
  1857.  
  1858.         /* r needs to be multiplied by 2 or 2*sqrt(2) depending on LM because
  1859.         short blocks don't have the same energy as long */
  1860.         r = pow(2, 1 - Ediff);
  1861.         if (s->duration == 3)
  1862.             r *= M_SQRT2;
  1863.         r = FFMIN(thresh, r) * sqrt_1;
  1864.         for (k = 0; k < 1 << s->duration; k++) {
  1865.             /* Detect collapse */
  1866.             if (!(frame->collapse_masks[i] & 1 << k)) {
  1867.                 /* Fill with noise */
  1868.                 for (j = 0; j < celt_freq_range[i]; j++)
  1869.                     xptr[(j << s->duration) + k] = (celt_rng(s) & 0x8000) ? r : -r;
  1870.                 renormalize = 1;
  1871.             }
  1872.         }
  1873.  
  1874.         /* We just added some energy, so we need to renormalize */
  1875.         if (renormalize)
  1876.             celt_renormalize_vector(xptr, celt_freq_range[i] << s->duration, 1.0f);
  1877.     }
  1878. }
  1879.  
  1880. static void celt_decode_bands(CeltContext *s, OpusRangeCoder *rc)
  1881. {
  1882.     float lowband_scratch[8 * 22];
  1883.     float norm[2 * 8 * 100];
  1884.  
  1885.     int totalbits = (s->framebits << 3) - s->anticollapse_bit;
  1886.  
  1887.     int update_lowband = 1;
  1888.     int lowband_offset = 0;
  1889.  
  1890.     int i, j;
  1891.  
  1892.     memset(s->coeffs, 0, sizeof(s->coeffs));
  1893.  
  1894.     for (i = s->startband; i < s->endband; i++) {
  1895.         int band_offset = celt_freq_bands[i] << s->duration;
  1896.         int band_size   = celt_freq_range[i] << s->duration;
  1897.         float *X = s->coeffs[0] + band_offset;
  1898.         float *Y = (s->coded_channels == 2) ? s->coeffs[1] + band_offset : NULL;
  1899.  
  1900.         int consumed = opus_rc_tell_frac(rc);
  1901.         float *norm2 = norm + 8 * 100;
  1902.         int effective_lowband = -1;
  1903.         unsigned int cm[2];
  1904.         int b;
  1905.  
  1906.         /* Compute how many bits we want to allocate to this band */
  1907.         if (i != s->startband)
  1908.             s->remaining -= consumed;
  1909.         s->remaining2 = totalbits - consumed - 1;
  1910.         if (i <= s->codedbands - 1) {
  1911.             int curr_balance = s->remaining / FFMIN(3, s->codedbands-i);
  1912.             b = av_clip_uintp2(FFMIN(s->remaining2 + 1, s->pulses[i] + curr_balance), 14);
  1913.         } else
  1914.             b = 0;
  1915.  
  1916.         if (celt_freq_bands[i] - celt_freq_range[i] >= celt_freq_bands[s->startband] &&
  1917.             (update_lowband || lowband_offset == 0))
  1918.             lowband_offset = i;
  1919.  
  1920.         /* Get a conservative estimate of the collapse_mask's for the bands we're
  1921.         going to be folding from. */
  1922.         if (lowband_offset != 0 && (s->spread != CELT_SPREAD_AGGRESSIVE ||
  1923.                                     s->blocks > 1 || s->tf_change[i] < 0)) {
  1924.             int foldstart, foldend;
  1925.  
  1926.             /* This ensures we never repeat spectral content within one band */
  1927.             effective_lowband = FFMAX(celt_freq_bands[s->startband],
  1928.                                       celt_freq_bands[lowband_offset] - celt_freq_range[i]);
  1929.             foldstart = lowband_offset;
  1930.             while (celt_freq_bands[--foldstart] > effective_lowband);
  1931.             foldend = lowband_offset - 1;
  1932.             while (celt_freq_bands[++foldend] < effective_lowband + celt_freq_range[i]);
  1933.  
  1934.             cm[0] = cm[1] = 0;
  1935.             for (j = foldstart; j < foldend; j++) {
  1936.                 cm[0] |= s->frame[0].collapse_masks[j];
  1937.                 cm[1] |= s->frame[s->coded_channels - 1].collapse_masks[j];
  1938.             }
  1939.         } else
  1940.             /* Otherwise, we'll be using the LCG to fold, so all blocks will (almost
  1941.             always) be non-zero.*/
  1942.             cm[0] = cm[1] = (1 << s->blocks) - 1;
  1943.  
  1944.         if (s->dualstereo && i == s->intensitystereo) {
  1945.             /* Switch off dual stereo to do intensity */
  1946.             s->dualstereo = 0;
  1947.             for (j = celt_freq_bands[s->startband] << s->duration; j < band_offset; j++)
  1948.                 norm[j] = (norm[j] + norm2[j]) / 2;
  1949.         }
  1950.  
  1951.         if (s->dualstereo) {
  1952.             cm[0] = celt_decode_band(s, rc, i, X, NULL, band_size, b / 2, s->blocks,
  1953.                                      effective_lowband != -1 ? norm + (effective_lowband << s->duration) : NULL, s->duration,
  1954.             norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]);
  1955.  
  1956.             cm[1] = celt_decode_band(s, rc, i, Y, NULL, band_size, b/2, s->blocks,
  1957.                                      effective_lowband != -1 ? norm2 + (effective_lowband << s->duration) : NULL, s->duration,
  1958.             norm2 + band_offset, 0, 1.0f, lowband_scratch, cm[1]);
  1959.         } else {
  1960.             cm[0] = celt_decode_band(s, rc, i, X, Y, band_size, b, s->blocks,
  1961.             effective_lowband != -1 ? norm + (effective_lowband << s->duration) : NULL, s->duration,
  1962.             norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]|cm[1]);
  1963.  
  1964.             cm[1] = cm[0];
  1965.         }
  1966.  
  1967.         s->frame[0].collapse_masks[i]                     = (uint8_t)cm[0];
  1968.         s->frame[s->coded_channels - 1].collapse_masks[i] = (uint8_t)cm[1];
  1969.         s->remaining += s->pulses[i] + consumed;
  1970.  
  1971.         /* Update the folding position only as long as we have 1 bit/sample depth */
  1972.         update_lowband = (b > band_size << 3);
  1973.     }
  1974. }
  1975.  
  1976. int ff_celt_decode_frame(CeltContext *s, OpusRangeCoder *rc,
  1977.                          float **output, int coded_channels, int frame_size,
  1978.                          int startband,  int endband)
  1979. {
  1980.     int i, j;
  1981.  
  1982.     int consumed;           // bits of entropy consumed thus far for this frame
  1983.     int silence = 0;
  1984.     int transient = 0;
  1985.     int anticollapse = 0;
  1986.     IMDCT15Context *imdct;
  1987.     float imdct_scale = 1.0;
  1988.  
  1989.     if (coded_channels != 1 && coded_channels != 2) {
  1990.         av_log(s->avctx, AV_LOG_ERROR, "Invalid number of coded channels: %d\n",
  1991.                coded_channels);
  1992.         return AVERROR_INVALIDDATA;
  1993.     }
  1994.     if (startband < 0 || startband > endband || endband > CELT_MAX_BANDS) {
  1995.         av_log(s->avctx, AV_LOG_ERROR, "Invalid start/end band: %d %d\n",
  1996.                startband, endband);
  1997.         return AVERROR_INVALIDDATA;
  1998.     }
  1999.  
  2000.     s->flushed        = 0;
  2001.     s->coded_channels = coded_channels;
  2002.     s->startband      = startband;
  2003.     s->endband        = endband;
  2004.     s->framebits      = rc->rb.bytes * 8;
  2005.  
  2006.     s->duration = av_log2(frame_size / CELT_SHORT_BLOCKSIZE);
  2007.     if (s->duration > CELT_MAX_LOG_BLOCKS ||
  2008.         frame_size != CELT_SHORT_BLOCKSIZE * (1 << s->duration)) {
  2009.         av_log(s->avctx, AV_LOG_ERROR, "Invalid CELT frame size: %d\n",
  2010.                frame_size);
  2011.         return AVERROR_INVALIDDATA;
  2012.     }
  2013.  
  2014.     if (!s->output_channels)
  2015.         s->output_channels = coded_channels;
  2016.  
  2017.     memset(s->frame[0].collapse_masks, 0, sizeof(s->frame[0].collapse_masks));
  2018.     memset(s->frame[1].collapse_masks, 0, sizeof(s->frame[1].collapse_masks));
  2019.  
  2020.     consumed = opus_rc_tell(rc);
  2021.  
  2022.     /* obtain silence flag */
  2023.     if (consumed >= s->framebits)
  2024.         silence = 1;
  2025.     else if (consumed == 1)
  2026.         silence = opus_rc_p2model(rc, 15);
  2027.  
  2028.  
  2029.     if (silence) {
  2030.         consumed = s->framebits;
  2031.         rc->total_read_bits += s->framebits - opus_rc_tell(rc);
  2032.     }
  2033.  
  2034.     /* obtain post-filter options */
  2035.     consumed = parse_postfilter(s, rc, consumed);
  2036.  
  2037.     /* obtain transient flag */
  2038.     if (s->duration != 0 && consumed+3 <= s->framebits)
  2039.         transient = opus_rc_p2model(rc, 3);
  2040.  
  2041.     s->blocks    = transient ? 1 << s->duration : 1;
  2042.     s->blocksize = frame_size / s->blocks;
  2043.  
  2044.     imdct = s->imdct[transient ? 0 : s->duration];
  2045.  
  2046.     if (coded_channels == 1) {
  2047.         for (i = 0; i < CELT_MAX_BANDS; i++)
  2048.             s->frame[0].energy[i] = FFMAX(s->frame[0].energy[i], s->frame[1].energy[i]);
  2049.     }
  2050.  
  2051.     celt_decode_coarse_energy(s, rc);
  2052.     celt_decode_tf_changes   (s, rc, transient);
  2053.     celt_decode_allocation   (s, rc);
  2054.     celt_decode_fine_energy  (s, rc);
  2055.     celt_decode_bands        (s, rc);
  2056.  
  2057.     if (s->anticollapse_bit)
  2058.         anticollapse = opus_getrawbits(rc, 1);
  2059.  
  2060.     celt_decode_final_energy(s, rc, s->framebits - opus_rc_tell(rc));
  2061.  
  2062.     /* apply anti-collapse processing and denormalization to
  2063.      * each coded channel */
  2064.     for (i = 0; i < s->coded_channels; i++) {
  2065.         CeltFrame *frame = &s->frame[i];
  2066.  
  2067.         if (anticollapse)
  2068.             process_anticollapse(s, frame, s->coeffs[i]);
  2069.  
  2070.         celt_denormalize(s, frame, s->coeffs[i]);
  2071.     }
  2072.  
  2073.     /* stereo -> mono downmix */
  2074.     if (s->output_channels < s->coded_channels) {
  2075.         s->dsp->vector_fmac_scalar(s->coeffs[0], s->coeffs[1], 1.0, FFALIGN(frame_size, 16));
  2076.         imdct_scale = 0.5;
  2077.     } else if (s->output_channels > s->coded_channels)
  2078.         memcpy(s->coeffs[1], s->coeffs[0], frame_size * sizeof(float));
  2079.  
  2080.     if (silence) {
  2081.         for (i = 0; i < 2; i++) {
  2082.             CeltFrame *frame = &s->frame[i];
  2083.  
  2084.             for (j = 0; j < FF_ARRAY_ELEMS(frame->energy); j++)
  2085.                 frame->energy[j] = CELT_ENERGY_SILENCE;
  2086.         }
  2087.         memset(s->coeffs, 0, sizeof(s->coeffs));
  2088.     }
  2089.  
  2090.     /* transform and output for each output channel */
  2091.     for (i = 0; i < s->output_channels; i++) {
  2092.         CeltFrame *frame = &s->frame[i];
  2093.         float m = frame->deemph_coeff;
  2094.  
  2095.         /* iMDCT and overlap-add */
  2096.         for (j = 0; j < s->blocks; j++) {
  2097.             float *dst  = frame->buf + 1024 + j * s->blocksize;
  2098.  
  2099.             imdct->imdct_half(imdct, dst + CELT_OVERLAP / 2, s->coeffs[i] + j,
  2100.                               s->blocks, imdct_scale);
  2101.             s->dsp->vector_fmul_window(dst, dst, dst + CELT_OVERLAP / 2,
  2102.                                       celt_window, CELT_OVERLAP / 2);
  2103.         }
  2104.  
  2105.         /* postfilter */
  2106.         celt_postfilter(s, frame);
  2107.  
  2108.         /* deemphasis and output scaling */
  2109.         for (j = 0; j < frame_size; j++) {
  2110.             float tmp = frame->buf[1024 - frame_size + j] + m;
  2111.             m = tmp * CELT_DEEMPH_COEFF;
  2112.             output[i][j] = tmp / 32768.;
  2113.         }
  2114.         frame->deemph_coeff = m;
  2115.     }
  2116.  
  2117.     if (coded_channels == 1)
  2118.         memcpy(s->frame[1].energy, s->frame[0].energy, sizeof(s->frame[0].energy));
  2119.  
  2120.     for (i = 0; i < 2; i++ ) {
  2121.         CeltFrame *frame = &s->frame[i];
  2122.  
  2123.         if (!transient) {
  2124.             memcpy(frame->prev_energy[1], frame->prev_energy[0], sizeof(frame->prev_energy[0]));
  2125.             memcpy(frame->prev_energy[0], frame->energy,         sizeof(frame->prev_energy[0]));
  2126.         } else {
  2127.             for (j = 0; j < CELT_MAX_BANDS; j++)
  2128.                 frame->prev_energy[0][j] = FFMIN(frame->prev_energy[0][j], frame->energy[j]);
  2129.         }
  2130.  
  2131.         for (j = 0; j < s->startband; j++) {
  2132.             frame->prev_energy[0][j] = CELT_ENERGY_SILENCE;
  2133.             frame->energy[j]         = 0.0;
  2134.         }
  2135.         for (j = s->endband; j < CELT_MAX_BANDS; j++) {
  2136.             frame->prev_energy[0][j] = CELT_ENERGY_SILENCE;
  2137.             frame->energy[j]         = 0.0;
  2138.         }
  2139.     }
  2140.  
  2141.     s->seed = rc->range;
  2142.  
  2143.     return 0;
  2144. }
  2145.  
  2146. void ff_celt_flush(CeltContext *s)
  2147. {
  2148.     int i, j;
  2149.  
  2150.     if (s->flushed)
  2151.         return;
  2152.  
  2153.     for (i = 0; i < 2; i++) {
  2154.         CeltFrame *frame = &s->frame[i];
  2155.  
  2156.         for (j = 0; j < CELT_MAX_BANDS; j++)
  2157.             frame->prev_energy[0][j] = frame->prev_energy[1][j] = CELT_ENERGY_SILENCE;
  2158.  
  2159.         memset(frame->energy, 0, sizeof(frame->energy));
  2160.         memset(frame->buf,    0, sizeof(frame->buf));
  2161.  
  2162.         memset(frame->pf_gains,     0, sizeof(frame->pf_gains));
  2163.         memset(frame->pf_gains_old, 0, sizeof(frame->pf_gains_old));
  2164.         memset(frame->pf_gains_new, 0, sizeof(frame->pf_gains_new));
  2165.  
  2166.         frame->deemph_coeff = 0.0;
  2167.     }
  2168.     s->seed = 0;
  2169.  
  2170.     s->flushed = 1;
  2171. }
  2172.  
  2173. void ff_celt_free(CeltContext **ps)
  2174. {
  2175.     CeltContext *s = *ps;
  2176.     int i;
  2177.  
  2178.     if (!s)
  2179.         return;
  2180.  
  2181.     for (i = 0; i < FF_ARRAY_ELEMS(s->imdct); i++)
  2182.         ff_imdct15_uninit(&s->imdct[i]);
  2183.  
  2184.     av_freep(&s->dsp);
  2185.     av_freep(ps);
  2186. }
  2187.  
  2188. int ff_celt_init(AVCodecContext *avctx, CeltContext **ps, int output_channels)
  2189. {
  2190.     CeltContext *s;
  2191.     int i, ret;
  2192.  
  2193.     if (output_channels != 1 && output_channels != 2) {
  2194.         av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",
  2195.                output_channels);
  2196.         return AVERROR(EINVAL);
  2197.     }
  2198.  
  2199.     s = av_mallocz(sizeof(*s));
  2200.     if (!s)
  2201.         return AVERROR(ENOMEM);
  2202.  
  2203.     s->avctx           = avctx;
  2204.     s->output_channels = output_channels;
  2205.  
  2206.     for (i = 0; i < FF_ARRAY_ELEMS(s->imdct); i++) {
  2207.         ret = ff_imdct15_init(&s->imdct[i], i + 3);
  2208.         if (ret < 0)
  2209.             goto fail;
  2210.     }
  2211.  
  2212.     s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
  2213.     if (!s->dsp) {
  2214.         ret = AVERROR(ENOMEM);
  2215.         goto fail;
  2216.     }
  2217.  
  2218.     ff_celt_flush(s);
  2219.  
  2220.     *ps = s;
  2221.  
  2222.     return 0;
  2223. fail:
  2224.     ff_celt_free(&s);
  2225.     return ret;
  2226. }
  2227.