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