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