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 "opus.h" 32#include "opus_imdct.h" 33 34enum CeltSpread { 35 CELT_SPREAD_NONE, 36 CELT_SPREAD_LIGHT, 37 CELT_SPREAD_NORMAL, 38 CELT_SPREAD_AGGRESSIVE 39}; 40 41typedef 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 61struct CeltContext { 62 // constant values that do not change during context lifetime 63 AVCodecContext *avctx; 64 CeltIMDCTContext *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 104static const uint16_t celt_model_tapset[] = { 4, 2, 3, 4 }; 105 106static const uint16_t celt_model_spread[] = { 32, 7, 9, 30, 32 }; 107 108static const uint16_t celt_model_alloc_trim[] = { 109 128, 2, 4, 9, 19, 41, 87, 109, 119, 124, 126, 128 110}; 111 112static const uint16_t celt_model_energy_small[] = { 4, 2, 3, 4 }; 113 114static 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 118static 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 122static 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 126static 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 133static 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 141static const float celt_alpha_coef[] = { 142 29440.0f/32768.0f, 26112.0f/32768.0f, 21248.0f/32768.0f, 16384.0f/32768.0f 143}; 144 145static 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 149static 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 193static 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 207static 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 231static 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 261static 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 271static 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 275static 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 279static 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 284static 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 291static const uint16_t celt_qn_exp2[] = { 292 16384, 17866, 19483, 21247, 23170, 25267, 27554, 30048 293}; 294 295static 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 438DECLARE_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 */ 466const 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 485static 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 493static 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 500static 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 512static inline uint32_t celt_rng(CeltContext *s) 513{ 514 s->seed = 1664525 * s->seed + 1013904223; 515 return s->seed; 516} 517 518static 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 568static 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 587static 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 609static 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 637static 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 969static 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 988static 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 994static 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 1002static 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 1027static 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 1063static 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 1084static 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 1096static 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 1136static 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 1157static 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 1178static 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 1192static 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 1209static 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 1294static 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. */ 1305static 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 1318static unsigned int celt_decode_band(CeltContext *s, OpusRangeCoder *rc, 1319 const int band, float *X, float *Y, 1320 int N, int b, unsigned int blocks, 1321 float *lowband, int duration, 1322 float *lowband_out, int level, 1323 float gain, float *lowband_scratch, 1324 int fill) 1325{ 1326 const uint8_t *cache; 1327 int dualstereo, split; 1328 int imid = 0, iside = 0; 1329 unsigned int N0 = N; 1330 int N_B; 1331 int N_B0; 1332 int B0 = blocks; 1333 int time_divide = 0; 1334 int recombine = 0; 1335 int inv = 0; 1336 float mid = 0, side = 0; 1337 int longblocks = (B0 == 1); 1338 unsigned int cm = 0; 1339 1340 N_B0 = N_B = N / blocks; 1341 split = dualstereo = (Y != NULL); 1342 1343 if (N == 1) { 1344 /* special case for one sample */ 1345 int i; 1346 float *x = X; 1347 for (i = 0; i <= dualstereo; i++) { 1348 int sign = 0; 1349 if (s->remaining2 >= 1<<3) { 1350 sign = opus_getrawbits(rc, 1); 1351 s->remaining2 -= 1 << 3; 1352 b -= 1 << 3; 1353 } 1354 x[0] = sign ? -1.0f : 1.0f; 1355 x = Y; 1356 } 1357 if (lowband_out) 1358 lowband_out[0] = X[0]; 1359 return 1; 1360 } 1361 1362 if (!dualstereo && level == 0) { 1363 int tf_change = s->tf_change[band]; 1364 int k; 1365 if (tf_change > 0) 1366 recombine = tf_change; 1367 /* Band recombining to increase frequency resolution */ 1368 1369 if (lowband && 1370 (recombine || ((N_B & 1) == 0 && tf_change < 0) || B0 > 1)) { 1371 int j; 1372 for (j = 0; j < N; j++) 1373 lowband_scratch[j] = lowband[j]; 1374 lowband = lowband_scratch; 1375 } 1376 1377 for (k = 0; k < recombine; k++) { 1378 if (lowband) 1379 celt_haar1(lowband, N >> k, 1 << k); 1380 fill = celt_bit_interleave[fill & 0xF] | celt_bit_interleave[fill >> 4] << 2; 1381 } 1382 blocks >>= recombine; 1383 N_B <<= recombine; 1384 1385 /* Increasing the time resolution */ 1386 while ((N_B & 1) == 0 && tf_change < 0) { 1387 if (lowband) 1388 celt_haar1(lowband, N_B, blocks); 1389 fill |= fill << blocks; 1390 blocks <<= 1; 1391 N_B >>= 1; 1392 time_divide++; 1393 tf_change++; 1394 } 1395 B0 = blocks; 1396 N_B0 = N_B; 1397 1398 /* Reorganize the samples in time order instead of frequency order */ 1399 if (B0 > 1 && lowband) 1400 celt_deinterleave_hadamard(s->scratch, lowband, N_B >> recombine, 1401 B0 << recombine, longblocks); 1402 } 1403 1404 /* If we need 1.5 more bit than we can produce, split the band in two. */ 1405 cache = celt_cache_bits + 1406 celt_cache_index[(duration + 1) * CELT_MAX_BANDS + band]; 1407 if (!dualstereo && duration >= 0 && b > cache[cache[0]] + 12 && N > 2) { 1408 N >>= 1; 1409 Y = X + N; 1410 split = 1; 1411 duration -= 1; 1412 if (blocks == 1) 1413 fill = (fill & 1) | (fill << 1); 1414 blocks = (blocks + 1) >> 1; 1415 } 1416 1417 if (split) { 1418 int qn; 1419 int itheta = 0; 1420 int mbits, sbits, delta; 1421 int qalloc; 1422 int pulse_cap; 1423 int offset; 1424 int orig_fill; 1425 int tell; 1426 1427 /* Decide on the resolution to give to the split parameter theta */ 1428 pulse_cap = celt_log_freq_range[band] + duration * 8; 1429 offset = (pulse_cap >> 1) - (dualstereo && N == 2 ? CELT_QTHETA_OFFSET_TWOPHASE : 1430 CELT_QTHETA_OFFSET); 1431 qn = (dualstereo && band >= s->intensitystereo) ? 1 : 1432 celt_compute_qn(N, b, offset, pulse_cap, dualstereo); 1433 tell = opus_rc_tell_frac(rc); 1434 if (qn != 1) { 1435 /* Entropy coding of the angle. We use a uniform pdf for the 1436 time split, a step for stereo, and a triangular one for the rest. */ 1437 if (dualstereo && N > 2) 1438 itheta = opus_rc_stepmodel(rc, qn/2); 1439 else if (dualstereo || B0 > 1) 1440 itheta = opus_rc_unimodel(rc, qn+1); 1441 else 1442 itheta = opus_rc_trimodel(rc, qn); 1443 itheta = itheta * 16384 / qn; 1444 /* NOTE: Renormalising X and Y *may* help fixed-point a bit at very high rate. 1445 Let's do that at higher complexity */ 1446 } else if (dualstereo) { 1447 inv = (b > 2 << 3 && s->remaining2 > 2 << 3) ? opus_rc_p2model(rc, 2) : 0; 1448 itheta = 0; 1449 } 1450 qalloc = opus_rc_tell_frac(rc) - tell; 1451 b -= qalloc; 1452 1453 orig_fill = fill; 1454 if (itheta == 0) { 1455 imid = 32767; 1456 iside = 0; 1457 fill &= (1 << blocks) - 1; 1458 delta = -16384; 1459 } else if (itheta == 16384) { 1460 imid = 0; 1461 iside = 32767; 1462 fill &= ((1 << blocks) - 1) << blocks; 1463 delta = 16384; 1464 } else { 1465 imid = celt_cos(itheta); 1466 iside = celt_cos(16384-itheta); 1467 /* This is the mid vs side allocation that minimizes squared error 1468 in that band. */ 1469 delta = ROUND_MUL16((N - 1) << 7, celt_log2tan(iside, imid)); 1470 } 1471 1472 mid = imid / 32768.0f; 1473 side = iside / 32768.0f; 1474 1475 /* This is a special case for N=2 that only works for stereo and takes 1476 advantage of the fact that mid and side are orthogonal to encode 1477 the side with just one bit. */ 1478 if (N == 2 && dualstereo) { 1479 int c; 1480 int sign = 0; 1481 float tmp; 1482 float *x2, *y2; 1483 mbits = b; 1484 /* Only need one bit for the side */ 1485 sbits = (itheta != 0 && itheta != 16384) ? 1 << 3 : 0; 1486 mbits -= sbits; 1487 c = (itheta > 8192); 1488 s->remaining2 -= qalloc+sbits; 1489 1490 x2 = c ? Y : X; 1491 y2 = c ? X : Y; 1492 if (sbits) 1493 sign = opus_getrawbits(rc, 1); 1494 sign = 1 - 2 * sign; 1495 /* We use orig_fill here because we want to fold the side, but if 1496 itheta==16384, we'll have cleared the low bits of fill. */ 1497 cm = celt_decode_band(s, rc, band, x2, NULL, N, mbits, blocks, 1498 lowband, duration, lowband_out, level, gain, 1499 lowband_scratch, orig_fill); 1500 /* We don't split N=2 bands, so cm is either 1 or 0 (for a fold-collapse), 1501 and there's no need to worry about mixing with the other channel. */ 1502 y2[0] = -sign * x2[1]; 1503 y2[1] = sign * x2[0]; 1504 X[0] *= mid; 1505 X[1] *= mid; 1506 Y[0] *= side; 1507 Y[1] *= side; 1508 tmp = X[0]; 1509 X[0] = tmp - Y[0]; 1510 Y[0] = tmp + Y[0]; 1511 tmp = X[1]; 1512 X[1] = tmp - Y[1]; 1513 Y[1] = tmp + Y[1]; 1514 } else { 1515 /* "Normal" split code */ 1516 float *next_lowband2 = NULL; 1517 float *next_lowband_out1 = NULL; 1518 int next_level = 0; 1519 int rebalance; 1520 1521 /* Give more bits to low-energy MDCTs than they would 1522 * otherwise deserve */ 1523 if (B0 > 1 && !dualstereo && (itheta & 0x3fff)) { 1524 if (itheta > 8192) 1525 /* Rough approximation for pre-echo masking */ 1526 delta -= delta >> (4 - duration); 1527 else 1528 /* Corresponds to a forward-masking slope of 1529 * 1.5 dB per 10 ms */ 1530 delta = FFMIN(0, delta + (N << 3 >> (5 - duration))); 1531 } 1532 mbits = av_clip((b - delta) / 2, 0, b); 1533 sbits = b - mbits; 1534 s->remaining2 -= qalloc; 1535 1536 if (lowband && !dualstereo) 1537 next_lowband2 = lowband + N; /* >32-bit split case */ 1538 1539 /* Only stereo needs to pass on lowband_out. 1540 * Otherwise, it's handled at the end */ 1541 if (dualstereo) 1542 next_lowband_out1 = lowband_out; 1543 else 1544 next_level = level + 1; 1545 1546 rebalance = s->remaining2; 1547 if (mbits >= sbits) { 1548 /* In stereo mode, we do not apply a scaling to the mid 1549 * because we need the normalized mid for folding later */ 1550 cm = celt_decode_band(s, rc, band, X, NULL, N, mbits, blocks, 1551 lowband, duration, next_lowband_out1, 1552 next_level, dualstereo ? 1.0f : (gain * mid), 1553 lowband_scratch, fill); 1554 1555 rebalance = mbits - (rebalance - s->remaining2); 1556 if (rebalance > 3 << 3 && itheta != 0) 1557 sbits += rebalance - (3 << 3); 1558 1559 /* For a stereo split, the high bits of fill are always zero, 1560 * so no folding will be done to the side. */ 1561 cm |= celt_decode_band(s, rc, band, Y, NULL, N, sbits, blocks, 1562 next_lowband2, duration, NULL, 1563 next_level, gain * side, NULL, 1564 fill >> blocks) << ((B0 >> 1) & (dualstereo - 1)); 1565 } else { 1566 /* For a stereo split, the high bits of fill are always zero, 1567 * so no folding will be done to the side. */ 1568 cm = celt_decode_band(s, rc, band, Y, NULL, N, sbits, blocks, 1569 next_lowband2, duration, NULL, 1570 next_level, gain * side, NULL, 1571 fill >> blocks) << ((B0 >> 1) & (dualstereo - 1)); 1572 1573 rebalance = sbits - (rebalance - s->remaining2); 1574 if (rebalance > 3 << 3 && itheta != 16384) 1575 mbits += rebalance - (3 << 3); 1576 1577 /* In stereo mode, we do not apply a scaling to the mid because 1578 * we need the normalized mid for folding later */ 1579 cm |= celt_decode_band(s, rc, band, X, NULL, N, mbits, blocks, 1580 lowband, duration, next_lowband_out1, 1581 next_level, dualstereo ? 1.0f : (gain * mid), 1582 lowband_scratch, fill); 1583 } 1584 } 1585 } else { 1586 /* This is the basic no-split case */ 1587 unsigned int q = celt_bits2pulses(cache, b); 1588 unsigned int curr_bits = celt_pulses2bits(cache, q); 1589 s->remaining2 -= curr_bits; 1590 1591 /* Ensures we can never bust the budget */ 1592 while (s->remaining2 < 0 && q > 0) { 1593 s->remaining2 += curr_bits; 1594 curr_bits = celt_pulses2bits(cache, --q); 1595 s->remaining2 -= curr_bits; 1596 } 1597 1598 if (q != 0) { 1599 /* Finally do the actual quantization */ 1600 cm = celt_alg_unquant(rc, X, N, (q < 8) ? q : (8 + (q & 7)) << ((q >> 3) - 1), 1601 s->spread, blocks, gain); 1602 } else { 1603 /* If there's no pulse, fill the band anyway */ 1604 int j; 1605 unsigned int cm_mask = (1 << blocks) - 1; 1606 fill &= cm_mask; 1607 if (!fill) { 1608 for (j = 0; j < N; j++) 1609 X[j] = 0.0f; 1610 } else { 1611 if (lowband == NULL) { 1612 /* Noise */ 1613 for (j = 0; j < N; j++) 1614 X[j] = (((int32_t)celt_rng(s)) >> 20); 1615 cm = cm_mask; 1616 } else { 1617 /* Folded spectrum */ 1618 for (j = 0; j < N; j++) { 1619 /* About 48 dB below the "normal" folding level */ 1620 X[j] = lowband[j] + (((celt_rng(s)) & 0x8000) ? 1.0f / 256 : -1.0f / 256); 1621 } 1622 cm = fill; 1623 } 1624 celt_renormalize_vector(X, N, gain); 1625 } 1626 } 1627 } 1628 1629 /* This code is used by the decoder and by the resynthesis-enabled encoder */ 1630 if (dualstereo) { 1631 int j; 1632 if (N != 2) 1633 celt_stereo_merge(X, Y, mid, N); 1634 if (inv) { 1635 for (j = 0; j < N; j++) 1636 Y[j] *= -1; 1637 } 1638 } else if (level == 0) { 1639 int k; 1640 1641 /* Undo the sample reorganization going from time order to frequency order */ 1642 if (B0 > 1) 1643 celt_interleave_hadamard(s->scratch, X, N_B>>recombine, 1644 B0<<recombine, longblocks); 1645 1646 /* Undo time-freq changes that we did earlier */ 1647 N_B = N_B0; 1648 blocks = B0; 1649 for (k = 0; k < time_divide; k++) { 1650 blocks >>= 1; 1651 N_B <<= 1; 1652 cm |= cm >> blocks; 1653 celt_haar1(X, N_B, blocks); 1654 } 1655 1656 for (k = 0; k < recombine; k++) { 1657 cm = celt_bit_deinterleave[cm]; 1658 celt_haar1(X, N0>>k, 1<<k); 1659 } 1660 blocks <<= recombine; 1661 1662 /* Scale output for later folding */ 1663 if (lowband_out) { 1664 int j; 1665 float n = sqrtf(N0); 1666 for (j = 0; j < N0; j++) 1667 lowband_out[j] = n * X[j]; 1668 } 1669 cm &= (1 << blocks) - 1; 1670 } 1671 return cm; 1672} 1673 1674static 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 1687static 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 1732static 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 1764static 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 1788static 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 1828static 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 1880static 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(FFMIN(s->remaining2 + 1, s->pulses[i] + curr_balance), 0, 16383); 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 1976int 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 CeltIMDCTContext *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 2146void 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 2173void 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_celt_imdct_uninit(&s->imdct[i]); 2183 2184 av_freep(ps); 2185} 2186 2187int ff_celt_init(AVCodecContext *avctx, CeltContext **ps, int output_channels) 2188{ 2189 CeltContext *s; 2190 int i, ret; 2191 2192 if (output_channels != 1 && output_channels != 2) { 2193 av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n", 2194 output_channels); 2195 return AVERROR(EINVAL); 2196 } 2197 2198 s = av_mallocz(sizeof(*s)); 2199 if (!s) 2200 return AVERROR(ENOMEM); 2201 2202 s->avctx = avctx; 2203 s->output_channels = output_channels; 2204 2205 for (i = 0; i < FF_ARRAY_ELEMS(s->imdct); i++) { 2206 ret = ff_celt_imdct_init(&s->imdct[i], i + 3); 2207 if (ret < 0) 2208 goto fail; 2209 } 2210 2211 avpriv_float_dsp_init(&s->dsp, avctx->flags & CODEC_FLAG_BITEXACT); 2212 2213 ff_celt_flush(s); 2214 2215 *ps = s; 2216 2217 return 0; 2218fail: 2219 ff_celt_free(&s); 2220 return ret; 2221} 2222