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