1 /* Copyright (c) 2007-2008 CSIRO
2 Copyright (c) 2007-2009 Xiph.Org Foundation
3 Written by Jean-Marc Valin */
4 /*
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions
7 are met:
8
9 - Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11
12 - Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
15
16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
20 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "quant_bands.h"
34 #include "laplace.h"
35 #include <math.h>
36 #include "os_support.h"
37 #include "arch.h"
38 #include "mathops.h"
39 #include "stack_alloc.h"
40 #include "rate.h"
41
42 #ifdef FIXED_POINT
43 /* Mean energy in each band quantized in Q4 */
44 const signed char eMeans[25] = {
45 103,100, 92, 85, 81,
46 77, 72, 70, 78, 75,
47 73, 71, 78, 74, 69,
48 72, 70, 74, 76, 71,
49 60, 60, 60, 60, 60
50 };
51 #else
52 /* Mean energy in each band quantized in Q4 and converted back to float */
53 const opus_val16 eMeans[25] = {
54 6.437500f, 6.250000f, 5.750000f, 5.312500f, 5.062500f,
55 4.812500f, 4.500000f, 4.375000f, 4.875000f, 4.687500f,
56 4.562500f, 4.437500f, 4.875000f, 4.625000f, 4.312500f,
57 4.500000f, 4.375000f, 4.625000f, 4.750000f, 4.437500f,
58 3.750000f, 3.750000f, 3.750000f, 3.750000f, 3.750000f
59 };
60 #endif
61 /* prediction coefficients: 0.9, 0.8, 0.65, 0.5 */
62 #ifdef FIXED_POINT
63 static const opus_val16 pred_coef[4] = {29440, 26112, 21248, 16384};
64 static const opus_val16 beta_coef[4] = {30147, 22282, 12124, 6554};
65 static const opus_val16 beta_intra = 4915;
66 #else
67 static const opus_val16 pred_coef[4] = {29440/32768., 26112/32768., 21248/32768., 16384/32768.};
68 static const opus_val16 beta_coef[4] = {30147/32768., 22282/32768., 12124/32768., 6554/32768.};
69 static const opus_val16 beta_intra = 4915/32768.;
70 #endif
71
72 /*Parameters of the Laplace-like probability models used for the coarse energy.
73 There is one pair of parameters for each frame size, prediction type
74 (inter/intra), and band number.
75 The first number of each pair is the probability of 0, and the second is the
76 decay rate, both in Q8 precision.*/
77 static const unsigned char e_prob_model[4][2][42] = {
78 /*120 sample frames.*/
79 {
80 /*Inter*/
81 {
82 72, 127, 65, 129, 66, 128, 65, 128, 64, 128, 62, 128, 64, 128,
83 64, 128, 92, 78, 92, 79, 92, 78, 90, 79, 116, 41, 115, 40,
84 114, 40, 132, 26, 132, 26, 145, 17, 161, 12, 176, 10, 177, 11
85 },
86 /*Intra*/
87 {
88 24, 179, 48, 138, 54, 135, 54, 132, 53, 134, 56, 133, 55, 132,
89 55, 132, 61, 114, 70, 96, 74, 88, 75, 88, 87, 74, 89, 66,
90 91, 67, 100, 59, 108, 50, 120, 40, 122, 37, 97, 43, 78, 50
91 }
92 },
93 /*240 sample frames.*/
94 {
95 /*Inter*/
96 {
97 83, 78, 84, 81, 88, 75, 86, 74, 87, 71, 90, 73, 93, 74,
98 93, 74, 109, 40, 114, 36, 117, 34, 117, 34, 143, 17, 145, 18,
99 146, 19, 162, 12, 165, 10, 178, 7, 189, 6, 190, 8, 177, 9
100 },
101 /*Intra*/
102 {
103 23, 178, 54, 115, 63, 102, 66, 98, 69, 99, 74, 89, 71, 91,
104 73, 91, 78, 89, 86, 80, 92, 66, 93, 64, 102, 59, 103, 60,
105 104, 60, 117, 52, 123, 44, 138, 35, 133, 31, 97, 38, 77, 45
106 }
107 },
108 /*480 sample frames.*/
109 {
110 /*Inter*/
111 {
112 61, 90, 93, 60, 105, 42, 107, 41, 110, 45, 116, 38, 113, 38,
113 112, 38, 124, 26, 132, 27, 136, 19, 140, 20, 155, 14, 159, 16,
114 158, 18, 170, 13, 177, 10, 187, 8, 192, 6, 175, 9, 159, 10
115 },
116 /*Intra*/
117 {
118 21, 178, 59, 110, 71, 86, 75, 85, 84, 83, 91, 66, 88, 73,
119 87, 72, 92, 75, 98, 72, 105, 58, 107, 54, 115, 52, 114, 55,
120 112, 56, 129, 51, 132, 40, 150, 33, 140, 29, 98, 35, 77, 42
121 }
122 },
123 /*960 sample frames.*/
124 {
125 /*Inter*/
126 {
127 42, 121, 96, 66, 108, 43, 111, 40, 117, 44, 123, 32, 120, 36,
128 119, 33, 127, 33, 134, 34, 139, 21, 147, 23, 152, 20, 158, 25,
129 154, 26, 166, 21, 173, 16, 184, 13, 184, 10, 150, 13, 139, 15
130 },
131 /*Intra*/
132 {
133 22, 178, 63, 114, 74, 82, 84, 83, 92, 82, 103, 62, 96, 72,
134 96, 67, 101, 73, 107, 72, 113, 55, 118, 52, 125, 52, 118, 52,
135 117, 55, 135, 49, 137, 39, 157, 32, 145, 29, 97, 33, 77, 40
136 }
137 }
138 };
139
140 static const unsigned char small_energy_icdf[3]={2,1,0};
141
loss_distortion(const opus_val16 * eBands,opus_val16 * oldEBands,int start,int end,int len,int C)142 static opus_val32 loss_distortion(const opus_val16 *eBands, opus_val16 *oldEBands, int start, int end, int len, int C)
143 {
144 int c, i;
145 opus_val32 dist = 0;
146 c=0; do {
147 for (i=start;i<end;i++)
148 {
149 opus_val16 d = SUB16(SHR16(eBands[i+c*len], 3), SHR16(oldEBands[i+c*len], 3));
150 dist = MAC16_16(dist, d,d);
151 }
152 } while (++c<C);
153 return MIN32(200,SHR32(dist,2*DB_SHIFT-6));
154 }
155
quant_coarse_energy_impl(const CELTMode * m,int start,int end,const opus_val16 * eBands,opus_val16 * oldEBands,opus_int32 budget,opus_int32 tell,const unsigned char * prob_model,opus_val16 * error,ec_enc * enc,int C,int LM,int intra,opus_val16 max_decay,int lfe)156 static int quant_coarse_energy_impl(const CELTMode *m, int start, int end,
157 const opus_val16 *eBands, opus_val16 *oldEBands,
158 opus_int32 budget, opus_int32 tell,
159 const unsigned char *prob_model, opus_val16 *error, ec_enc *enc,
160 int C, int LM, int intra, opus_val16 max_decay, int lfe)
161 {
162 int i, c;
163 int badness = 0;
164 opus_val32 prev[2] = {0,0};
165 opus_val16 coef;
166 opus_val16 beta;
167
168 if (tell+3 <= budget)
169 ec_enc_bit_logp(enc, intra, 3);
170 if (intra)
171 {
172 coef = 0;
173 beta = beta_intra;
174 } else {
175 beta = beta_coef[LM];
176 coef = pred_coef[LM];
177 }
178
179 /* Encode at a fixed coarse resolution */
180 for (i=start;i<end;i++)
181 {
182 c=0;
183 do {
184 int bits_left;
185 int qi, qi0;
186 opus_val32 q;
187 opus_val16 x;
188 opus_val32 f, tmp;
189 opus_val16 oldE;
190 opus_val16 decay_bound;
191 x = eBands[i+c*m->nbEBands];
192 oldE = MAX16(-QCONST16(9.f,DB_SHIFT), oldEBands[i+c*m->nbEBands]);
193 #ifdef FIXED_POINT
194 f = SHL32(EXTEND32(x),7) - PSHR32(MULT16_16(coef,oldE), 8) - prev[c];
195 /* Rounding to nearest integer here is really important! */
196 qi = (f+QCONST32(.5f,DB_SHIFT+7))>>(DB_SHIFT+7);
197 decay_bound = EXTRACT16(MAX32(-QCONST16(28.f,DB_SHIFT),
198 SUB32((opus_val32)oldEBands[i+c*m->nbEBands],max_decay)));
199 #else
200 f = x-coef*oldE-prev[c];
201 /* Rounding to nearest integer here is really important! */
202 qi = (int)floor(.5f+f);
203 decay_bound = MAX16(-QCONST16(28.f,DB_SHIFT), oldEBands[i+c*m->nbEBands]) - max_decay;
204 #endif
205 /* Prevent the energy from going down too quickly (e.g. for bands
206 that have just one bin) */
207 if (qi < 0 && x < decay_bound)
208 {
209 qi += (int)SHR16(SUB16(decay_bound,x), DB_SHIFT);
210 if (qi > 0)
211 qi = 0;
212 }
213 qi0 = qi;
214 /* If we don't have enough bits to encode all the energy, just assume
215 something safe. */
216 tell = ec_tell(enc);
217 bits_left = budget-tell-3*C*(end-i);
218 if (i!=start && bits_left < 30)
219 {
220 if (bits_left < 24)
221 qi = IMIN(1, qi);
222 if (bits_left < 16)
223 qi = IMAX(-1, qi);
224 }
225 if (lfe && i>=2)
226 qi = IMIN(qi, 0);
227 if (budget-tell >= 15)
228 {
229 int pi;
230 pi = 2*IMIN(i,20);
231 ec_laplace_encode(enc, &qi,
232 prob_model[pi]<<7, prob_model[pi+1]<<6);
233 }
234 else if(budget-tell >= 2)
235 {
236 qi = IMAX(-1, IMIN(qi, 1));
237 ec_enc_icdf(enc, 2*qi^-(qi<0), small_energy_icdf, 2);
238 }
239 else if(budget-tell >= 1)
240 {
241 qi = IMIN(0, qi);
242 ec_enc_bit_logp(enc, -qi, 1);
243 }
244 else
245 qi = -1;
246 error[i+c*m->nbEBands] = PSHR32(f,7) - SHL16(qi,DB_SHIFT);
247 badness += abs(qi0-qi);
248 q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT);
249
250 tmp = PSHR32(MULT16_16(coef,oldE),8) + prev[c] + SHL32(q,7);
251 #ifdef FIXED_POINT
252 tmp = MAX32(-QCONST32(28.f, DB_SHIFT+7), tmp);
253 #endif
254 oldEBands[i+c*m->nbEBands] = PSHR32(tmp, 7);
255 prev[c] = prev[c] + SHL32(q,7) - MULT16_16(beta,PSHR32(q,8));
256 } while (++c < C);
257 }
258 return lfe ? 0 : badness;
259 }
260
quant_coarse_energy(const CELTMode * m,int start,int end,int effEnd,const opus_val16 * eBands,opus_val16 * oldEBands,opus_uint32 budget,opus_val16 * error,ec_enc * enc,int C,int LM,int nbAvailableBytes,int force_intra,opus_val32 * delayedIntra,int two_pass,int loss_rate,int lfe)261 void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
262 const opus_val16 *eBands, opus_val16 *oldEBands, opus_uint32 budget,
263 opus_val16 *error, ec_enc *enc, int C, int LM, int nbAvailableBytes,
264 int force_intra, opus_val32 *delayedIntra, int two_pass, int loss_rate, int lfe)
265 {
266 int intra;
267 opus_val16 max_decay;
268 VARDECL(opus_val16, oldEBands_intra);
269 VARDECL(opus_val16, error_intra);
270 ec_enc enc_start_state;
271 opus_uint32 tell;
272 int badness1=0;
273 opus_int32 intra_bias;
274 opus_val32 new_distortion;
275 SAVE_STACK;
276
277 intra = force_intra || (!two_pass && *delayedIntra>2*C*(end-start) && nbAvailableBytes > (end-start)*C);
278 intra_bias = (opus_int32)((budget**delayedIntra*loss_rate)/(C*512));
279 new_distortion = loss_distortion(eBands, oldEBands, start, effEnd, m->nbEBands, C);
280
281 tell = ec_tell(enc);
282 if (tell+3 > budget)
283 two_pass = intra = 0;
284
285 max_decay = QCONST16(16.f,DB_SHIFT);
286 if (end-start>10)
287 {
288 #ifdef FIXED_POINT
289 max_decay = MIN32(max_decay, SHL32(EXTEND32(nbAvailableBytes),DB_SHIFT-3));
290 #else
291 max_decay = MIN32(max_decay, .125f*nbAvailableBytes);
292 #endif
293 }
294 if (lfe)
295 max_decay = QCONST16(3.f,DB_SHIFT);
296 enc_start_state = *enc;
297
298 ALLOC(oldEBands_intra, C*m->nbEBands, opus_val16);
299 ALLOC(error_intra, C*m->nbEBands, opus_val16);
300 OPUS_COPY(oldEBands_intra, oldEBands, C*m->nbEBands);
301
302 if (two_pass || intra)
303 {
304 badness1 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands_intra, budget,
305 tell, e_prob_model[LM][1], error_intra, enc, C, LM, 1, max_decay, lfe);
306 }
307
308 if (!intra)
309 {
310 unsigned char *intra_buf;
311 ec_enc enc_intra_state;
312 opus_int32 tell_intra;
313 opus_uint32 nstart_bytes;
314 opus_uint32 nintra_bytes;
315 opus_uint32 save_bytes;
316 int badness2;
317 VARDECL(unsigned char, intra_bits);
318
319 tell_intra = ec_tell_frac(enc);
320
321 enc_intra_state = *enc;
322
323 nstart_bytes = ec_range_bytes(&enc_start_state);
324 nintra_bytes = ec_range_bytes(&enc_intra_state);
325 intra_buf = ec_get_buffer(&enc_intra_state) + nstart_bytes;
326 save_bytes = nintra_bytes-nstart_bytes;
327 if (save_bytes == 0)
328 save_bytes = ALLOC_NONE;
329 ALLOC(intra_bits, save_bytes, unsigned char);
330 /* Copy bits from intra bit-stream */
331 OPUS_COPY(intra_bits, intra_buf, nintra_bytes - nstart_bytes);
332
333 *enc = enc_start_state;
334
335 badness2 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands, budget,
336 tell, e_prob_model[LM][intra], error, enc, C, LM, 0, max_decay, lfe);
337
338 if (two_pass && (badness1 < badness2 || (badness1 == badness2 && ((opus_int32)ec_tell_frac(enc))+intra_bias > tell_intra)))
339 {
340 *enc = enc_intra_state;
341 /* Copy intra bits to bit-stream */
342 OPUS_COPY(intra_buf, intra_bits, nintra_bytes - nstart_bytes);
343 OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
344 OPUS_COPY(error, error_intra, C*m->nbEBands);
345 intra = 1;
346 }
347 } else {
348 OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
349 OPUS_COPY(error, error_intra, C*m->nbEBands);
350 }
351
352 if (intra)
353 *delayedIntra = new_distortion;
354 else
355 *delayedIntra = ADD32(MULT16_32_Q15(MULT16_16_Q15(pred_coef[LM], pred_coef[LM]),*delayedIntra),
356 new_distortion);
357
358 RESTORE_STACK;
359 }
360
quant_fine_energy(const CELTMode * m,int start,int end,opus_val16 * oldEBands,opus_val16 * error,int * fine_quant,ec_enc * enc,int C)361 void quant_fine_energy(const CELTMode *m, int start, int end, opus_val16 *oldEBands, opus_val16 *error, int *fine_quant, ec_enc *enc, int C)
362 {
363 int i, c;
364
365 /* Encode finer resolution */
366 for (i=start;i<end;i++)
367 {
368 opus_int16 frac = 1<<fine_quant[i];
369 if (fine_quant[i] <= 0)
370 continue;
371 c=0;
372 do {
373 int q2;
374 opus_val16 offset;
375 #ifdef FIXED_POINT
376 /* Has to be without rounding */
377 q2 = (error[i+c*m->nbEBands]+QCONST16(.5f,DB_SHIFT))>>(DB_SHIFT-fine_quant[i]);
378 #else
379 q2 = (int)floor((error[i+c*m->nbEBands]+.5f)*frac);
380 #endif
381 if (q2 > frac-1)
382 q2 = frac-1;
383 if (q2<0)
384 q2 = 0;
385 ec_enc_bits(enc, q2, fine_quant[i]);
386 #ifdef FIXED_POINT
387 offset = SUB16(SHR32(SHL32(EXTEND32(q2),DB_SHIFT)+QCONST16(.5f,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
388 #else
389 offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
390 #endif
391 oldEBands[i+c*m->nbEBands] += offset;
392 error[i+c*m->nbEBands] -= offset;
393 /*printf ("%f ", error[i] - offset);*/
394 } while (++c < C);
395 }
396 }
397
quant_energy_finalise(const CELTMode * m,int start,int end,opus_val16 * oldEBands,opus_val16 * error,int * fine_quant,int * fine_priority,int bits_left,ec_enc * enc,int C)398 void quant_energy_finalise(const CELTMode *m, int start, int end, opus_val16 *oldEBands, opus_val16 *error, int *fine_quant, int *fine_priority, int bits_left, ec_enc *enc, int C)
399 {
400 int i, prio, c;
401
402 /* Use up the remaining bits */
403 for (prio=0;prio<2;prio++)
404 {
405 for (i=start;i<end && bits_left>=C ;i++)
406 {
407 if (fine_quant[i] >= MAX_FINE_BITS || fine_priority[i]!=prio)
408 continue;
409 c=0;
410 do {
411 int q2;
412 opus_val16 offset;
413 q2 = error[i+c*m->nbEBands]<0 ? 0 : 1;
414 ec_enc_bits(enc, q2, 1);
415 #ifdef FIXED_POINT
416 offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5f,DB_SHIFT),fine_quant[i]+1);
417 #else
418 offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
419 #endif
420 oldEBands[i+c*m->nbEBands] += offset;
421 error[i+c*m->nbEBands] -= offset;
422 bits_left--;
423 } while (++c < C);
424 }
425 }
426 }
427
unquant_coarse_energy(const CELTMode * m,int start,int end,opus_val16 * oldEBands,int intra,ec_dec * dec,int C,int LM)428 void unquant_coarse_energy(const CELTMode *m, int start, int end, opus_val16 *oldEBands, int intra, ec_dec *dec, int C, int LM)
429 {
430 const unsigned char *prob_model = e_prob_model[LM][intra];
431 int i, c;
432 opus_val32 prev[2] = {0, 0};
433 opus_val16 coef;
434 opus_val16 beta;
435 opus_int32 budget;
436 opus_int32 tell;
437
438 if (intra)
439 {
440 coef = 0;
441 beta = beta_intra;
442 } else {
443 beta = beta_coef[LM];
444 coef = pred_coef[LM];
445 }
446
447 budget = dec->storage*8;
448
449 /* Decode at a fixed coarse resolution */
450 for (i=start;i<end;i++)
451 {
452 c=0;
453 do {
454 int qi;
455 opus_val32 q;
456 opus_val32 tmp;
457 /* It would be better to express this invariant as a
458 test on C at function entry, but that isn't enough
459 to make the static analyzer happy. */
460 celt_sig_assert(c<2);
461 tell = ec_tell(dec);
462 if(budget-tell>=15)
463 {
464 int pi;
465 pi = 2*IMIN(i,20);
466 qi = ec_laplace_decode(dec,
467 prob_model[pi]<<7, prob_model[pi+1]<<6);
468 }
469 else if(budget-tell>=2)
470 {
471 qi = ec_dec_icdf(dec, small_energy_icdf, 2);
472 qi = (qi>>1)^-(qi&1);
473 }
474 else if(budget-tell>=1)
475 {
476 qi = -ec_dec_bit_logp(dec, 1);
477 }
478 else
479 qi = -1;
480 q = (opus_val32)SHL32(EXTEND32(qi),DB_SHIFT);
481
482 oldEBands[i+c*m->nbEBands] = MAX16(-QCONST16(9.f,DB_SHIFT), oldEBands[i+c*m->nbEBands]);
483 tmp = PSHR32(MULT16_16(coef,oldEBands[i+c*m->nbEBands]),8) + prev[c] + SHL32(q,7);
484 #ifdef FIXED_POINT
485 tmp = MAX32(-QCONST32(28.f, DB_SHIFT+7), tmp);
486 #endif
487 oldEBands[i+c*m->nbEBands] = PSHR32(tmp, 7);
488 prev[c] = prev[c] + SHL32(q,7) - MULT16_16(beta,PSHR32(q,8));
489 } while (++c < C);
490 }
491 }
492
unquant_fine_energy(const CELTMode * m,int start,int end,opus_val16 * oldEBands,int * fine_quant,ec_dec * dec,int C)493 void unquant_fine_energy(const CELTMode *m, int start, int end, opus_val16 *oldEBands, int *fine_quant, ec_dec *dec, int C)
494 {
495 int i, c;
496 /* Decode finer resolution */
497 for (i=start;i<end;i++)
498 {
499 if (fine_quant[i] <= 0)
500 continue;
501 c=0;
502 do {
503 int q2;
504 opus_val16 offset;
505 q2 = ec_dec_bits(dec, fine_quant[i]);
506 #ifdef FIXED_POINT
507 offset = SUB16(SHR32(SHL32(EXTEND32(q2),DB_SHIFT)+QCONST16(.5f,DB_SHIFT),fine_quant[i]),QCONST16(.5f,DB_SHIFT));
508 #else
509 offset = (q2+.5f)*(1<<(14-fine_quant[i]))*(1.f/16384) - .5f;
510 #endif
511 oldEBands[i+c*m->nbEBands] += offset;
512 } while (++c < C);
513 }
514 }
515
unquant_energy_finalise(const CELTMode * m,int start,int end,opus_val16 * oldEBands,int * fine_quant,int * fine_priority,int bits_left,ec_dec * dec,int C)516 void unquant_energy_finalise(const CELTMode *m, int start, int end, opus_val16 *oldEBands, int *fine_quant, int *fine_priority, int bits_left, ec_dec *dec, int C)
517 {
518 int i, prio, c;
519
520 /* Use up the remaining bits */
521 for (prio=0;prio<2;prio++)
522 {
523 for (i=start;i<end && bits_left>=C ;i++)
524 {
525 if (fine_quant[i] >= MAX_FINE_BITS || fine_priority[i]!=prio)
526 continue;
527 c=0;
528 do {
529 int q2;
530 opus_val16 offset;
531 q2 = ec_dec_bits(dec, 1);
532 #ifdef FIXED_POINT
533 offset = SHR16(SHL16(q2,DB_SHIFT)-QCONST16(.5f,DB_SHIFT),fine_quant[i]+1);
534 #else
535 offset = (q2-.5f)*(1<<(14-fine_quant[i]-1))*(1.f/16384);
536 #endif
537 oldEBands[i+c*m->nbEBands] += offset;
538 bits_left--;
539 } while (++c < C);
540 }
541 }
542 }
543
amp2Log2(const CELTMode * m,int effEnd,int end,celt_ener * bandE,opus_val16 * bandLogE,int C)544 void amp2Log2(const CELTMode *m, int effEnd, int end,
545 celt_ener *bandE, opus_val16 *bandLogE, int C)
546 {
547 int c, i;
548 c=0;
549 do {
550 for (i=0;i<effEnd;i++)
551 {
552 bandLogE[i+c*m->nbEBands] =
553 celt_log2(bandE[i+c*m->nbEBands])
554 - SHL16((opus_val16)eMeans[i],6);
555 #ifdef FIXED_POINT
556 /* Compensate for bandE[] being Q12 but celt_log2() taking a Q14 input. */
557 bandLogE[i+c*m->nbEBands] += QCONST16(2.f, DB_SHIFT);
558 #endif
559 }
560 for (i=effEnd;i<end;i++)
561 bandLogE[c*m->nbEBands+i] = -QCONST16(14.f,DB_SHIFT);
562 } while (++c < C);
563 }
564