git.sesse.net Git - ffmpeg/blob - libavcodec/opus_celt.c

   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 &= (1 << blocks) - 1;
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 &= (1 << blocks) - 1;
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 & 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 }