Use a smarter per-band bitrate cap.
[opus.git] / libcelt / rate.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 <math.h>
38 #include "modes.h"
39 #include "cwrs.h"
40 #include "arch.h"
41 #include "os_support.h"
42
43 #include "entcode.h"
44 #include "rate.h"
45
46
47 static const unsigned char LOG2_FRAC_TABLE[24]={
48    0,
49    8,13,
50   16,19,21,23,
51   24,26,27,28,29,30,31,32,
52   32,33,34,34,35,36,36,37,37
53 };
54
55 #ifndef STATIC_MODES
56
57 /*Determines if V(N,K) fits in a 32-bit unsigned integer.
58   N and K are themselves limited to 15 bits.*/
59 static int fits_in32(int _n, int _k)
60 {
61    static const celt_int16 maxN[15] = {
62       32767, 32767, 32767, 1476, 283, 109,  60,  40,
63        29,  24,  20,  18,  16,  14,  13};
64    static const celt_int16 maxK[15] = {
65       32767, 32767, 32767, 32767, 1172, 238,  95,  53,
66        36,  27,  22,  18,  16,  15,  13};
67    if (_n>=14)
68    {
69       if (_k>=14)
70          return 0;
71       else
72          return _n <= maxN[_k];
73    } else {
74       return _k <= maxK[_n];
75    }
76 }
77
78 void compute_pulse_cache(CELTMode *m, int LM)
79 {
80    int C;
81    int i;
82    int j;
83    int curr=0;
84    int nbEntries=0;
85    int entryN[100], entryK[100], entryI[100];
86    const celt_int16 *eBands = m->eBands;
87    PulseCache *cache = &m->cache;
88    celt_int16 *cindex;
89    unsigned char *bits;
90    unsigned char *cap;
91
92    cindex = celt_alloc(sizeof(cache->index[0])*m->nbEBands*(LM+2));
93    cache->index = cindex;
94
95    /* Scan for all unique band sizes */
96    for (i=0;i<=LM+1;i++)
97    {
98       for (j=0;j<m->nbEBands;j++)
99       {
100          int k;
101          int N = (eBands[j+1]-eBands[j])<<i>>1;
102          cindex[i*m->nbEBands+j] = -1;
103          /* Find other bands that have the same size */
104          for (k=0;k<=i;k++)
105          {
106             int n;
107             for (n=0;n<m->nbEBands && (k!=i || n<j);n++)
108             {
109                if (N == (eBands[n+1]-eBands[n])<<k>>1)
110                {
111                   cindex[i*m->nbEBands+j] = cindex[k*m->nbEBands+n];
112                   break;
113                }
114             }
115          }
116          if (cache->index[i*m->nbEBands+j] == -1 && N!=0)
117          {
118             int K;
119             entryN[nbEntries] = N;
120             K = 0;
121             while (fits_in32(N,get_pulses(K+1)) && K<MAX_PSEUDO)
122                K++;
123             entryK[nbEntries] = K;
124             cindex[i*m->nbEBands+j] = curr;
125             entryI[nbEntries] = curr;
126
127             curr += K+1;
128             nbEntries++;
129          }
130       }
131    }
132    bits = celt_alloc(sizeof(unsigned char)*curr);
133    cache->bits = bits;
134    cache->size = curr;
135    /* Compute the cache for all unique sizes */
136    for (i=0;i<nbEntries;i++)
137    {
138       unsigned char *ptr = bits+entryI[i];
139       celt_int16 tmp[MAX_PULSES+1];
140       get_required_bits(tmp, entryN[i], get_pulses(entryK[i]), BITRES);
141       for (j=1;j<=entryK[i];j++)
142          ptr[j] = tmp[get_pulses(j)]-1;
143       ptr[0] = entryK[i];
144    }
145
146    /* Compute the maximum rate for each band at which we'll reliably use as
147        many bits as we ask for. */
148    cache->caps = cap = celt_alloc(sizeof(cache->caps[0])*(LM+1)*2*m->nbEBands);
149    for (i=0;i<=LM;i++)
150    {
151       for (C=1;C<=2;C++)
152       {
153          int shift;
154          shift = C+i+BITRES-2;
155          for (j=0;j<m->nbEBands;j++)
156          {
157             int N0;
158             int max_bits;
159             int rmask;
160             N0 = m->eBands[j+1]-m->eBands[j];
161             rmask = N0==1 ? (1<<shift)-1 : 0;
162             /* N=1 bands only have a sign bit and fine bits. */
163             if (N0<<i == 1)
164               max_bits = C*(1+MAX_FINE_BITS)<<BITRES;
165             else
166             {
167                const unsigned char *pcache;
168                celt_int32           num;
169                celt_int32           den;
170                int                  LM0;
171                int                  N;
172                int                  offset;
173                int                  ndof;
174                int                  qb;
175                int                  k;
176                LM0 = 0;
177                /* Even-sized bands bigger than N=4 can be split one more
178                    time (N=4 also _can_ be split, but not without waste: the
179                    result can only use 26 bits, but requires an allocation
180                    of 32 to trigger the split). */
181                if (N0 > 4 && !(N0&1))
182                {
183                   N0>>=1;
184                   LM0--;
185                }
186                /* N0=1 and N0=2 bands can't be split down to N=2. */
187                else if (N0 <= 2)
188                {
189                   LM0=IMIN(i,3-N0);
190                   N0<<=LM0;
191                }
192                /* Compute the cost for the lowest-level PVQ of a fully split
193                    band. */
194                pcache = bits + cindex[(LM0+1)*m->nbEBands+j];
195                max_bits = pcache[pcache[0]]+1;
196                /* Add in the cost of coding regular splits. */
197                N = N0;
198                for(k=0;k<i-LM0;k++){
199                   max_bits <<= 1;
200                   /* Offset the number of qtheta bits by log2(N)/2
201                       + QTHETA_OFFSET compared to their "fair share" of
202                       total/N */
203                   offset = (m->logN[j]+(LM0+k<<BITRES)>>1)-QTHETA_OFFSET;
204                   /* The number of qtheta bits we'll allocate if the remainder
205                       is to be max_bits. */
206                   num=(celt_int32)((2*N-1)*offset+max_bits)<<9;
207                   den=((celt_int32)(2*N-1)<<9)-495;
208                   qb = IMIN((num+(den>>1))/den, 8<<BITRES);
209                   celt_assert(qb >= 0);
210                   /* The average cost for theta when qn==256 is
211                       7.73246 bits for the triangular PDF. */
212                   max_bits += qb*495+256>>9;
213                   N <<= 1;
214                }
215                /* Add in the cost of a stereo split, if necessary. */
216                if (C==2)
217                {
218                   max_bits <<= 1;
219                   offset = (m->logN[j]+(i<<BITRES)>>1)-QTHETA_OFFSET_STEREO;
220                   ndof = 2*N-1-(N==2);
221                   num = (celt_int32)(max_bits+ndof*offset)<<7;
222                   den = ((celt_int32)ndof<<7)-(N==2?128:125);
223                   qb = IMIN((num+(den>>1))/den, 8<<BITRES);
224                   celt_assert(qb >= 0);
225                   /* The average cost for theta when qn==256, N>2 is
226                       7.8174 bits for the step PDF. */
227                   max_bits += N==2 ? qb : (qb*125+64>>7);
228                }
229                /* Add the fine bits we'll use. */
230                /* Compensate for the extra DoF in stereo */
231                ndof = C*N + ((C==2 && N>2) ? 1 : 0);
232                /* Offset the number of fine bits by log2(N)/2 + FINE_OFFSET
233                    compared to their "fair share" of total/N */
234                offset = (m->logN[j] + (i<<BITRES)>>1)-FINE_OFFSET;
235                /* N=2 is the only point that doesn't match the curve */
236                if (N==2)
237                   offset += 1<<BITRES>>2;
238                /* The number of fine bits we'll allocate if the remainder is
239                    to be max_bits. */
240                num = max_bits+ndof*offset;
241                den = ndof-1<<BITRES;
242                qb = IMIN((num+(den>>1))/den, MAX_FINE_BITS);
243                celt_assert(qb >= 0);
244                max_bits += C*qb<<BITRES;
245             }
246             celt_assert(max_bits+rmask>>shift < 256);
247             *cap++ = (unsigned char)(max_bits+rmask>>shift);
248          }
249       }
250    }
251 }
252
253 #endif /* !STATIC_MODES */
254
255
256 #define ALLOC_STEPS 6
257
258 static inline int interp_bits2pulses(const CELTMode *m, int start, int end, int skip_start,
259       const int *bits1, const int *bits2, const int *thresh, const int *cap, int total, int skip_rsv,
260       int *intensity, int intensity_rsv, int *dual_stereo, int dual_stereo_rsv, int *bits,
261       int *ebits, int *fine_priority, int _C, int LM, void *ec, int encode, int prev)
262 {
263    int psum;
264    int lo, hi;
265    int i, j;
266    int logM;
267    const int C = CHANNELS(_C);
268    int stereo;
269    int codedBands=-1;
270    int alloc_floor;
271    int left, percoeff;
272    int done;
273    int balance;
274    SAVE_STACK;
275
276    alloc_floor = C<<BITRES;
277    stereo = C>1;
278
279    logM = LM<<BITRES;
280    lo = 0;
281    hi = 1<<ALLOC_STEPS;
282    for (i=0;i<ALLOC_STEPS;i++)
283    {
284       int mid = (lo+hi)>>1;
285       psum = 0;
286       done = 0;
287       for (j=end;j-->start;)
288       {
289          int tmp = bits1[j] + (mid*bits2[j]>>ALLOC_STEPS);
290          if (tmp >= thresh[j] || done)
291          {
292             done = 1;
293             /* Don't allocate more than we can actually use */
294             psum += IMIN(tmp, cap[j]);
295          } else {
296             if (tmp >= alloc_floor)
297                psum += alloc_floor;
298          }
299       }
300       if (psum > total)
301          hi = mid;
302       else
303          lo = mid;
304    }
305    psum = 0;
306    /*printf ("interp bisection gave %d\n", lo);*/
307    done = 0;
308    for (j=end;j-->start;)
309    {
310       int tmp = bits1[j] + (lo*bits2[j]>>ALLOC_STEPS);
311       if (tmp < thresh[j] && !done)
312       {
313          if (tmp >= alloc_floor)
314             tmp = alloc_floor;
315          else
316             tmp = 0;
317       } else
318          done = 1;
319       /* Don't allocate more than we can actually use */
320       tmp = IMIN(tmp, cap[j]);
321       bits[j] = tmp;
322       psum += tmp;
323    }
324
325    /* Decide which bands to skip, working backwards from the end. */
326    for (codedBands=end;;codedBands--)
327    {
328       int band_width;
329       int band_bits;
330       int rem;
331       j = codedBands-1;
332       /* Never skip the first band, nor a band that has been boosted by
333           dynalloc.
334          In the first case, we'd be coding a bit to signal we're going to waste
335           all the other bits.
336          In the second case, we'd be coding a bit to redistribute all the bits
337           we just signaled should be cocentrated in this band. */
338       if (j<=skip_start)
339       {
340          /* Give the bit we reserved to end skipping back. */
341          total += skip_rsv;
342          break;
343       }
344       /*Figure out how many left-over bits we would be adding to this band.
345         This can include bits we've stolen back from higher, skipped bands.*/
346       left = total-psum;
347       percoeff = left/(m->eBands[codedBands]-m->eBands[start]);
348       left -= (m->eBands[codedBands]-m->eBands[start])*percoeff;
349       rem = IMAX(left-(m->eBands[j]-m->eBands[start]),0);
350       band_width = m->eBands[codedBands]-m->eBands[j];
351       band_bits = bits[j] + percoeff*band_width + rem;
352       /*Only code a skip decision if we're above the threshold for this band.
353         Otherwise it is force-skipped.
354         This ensures that we have enough bits to code the skip flag.*/
355       if (band_bits >= IMAX(thresh[j], alloc_floor+(1<<BITRES)))
356       {
357          if (encode)
358          {
359             /*This if() block is the only part of the allocation function that
360                is not a mandatory part of the bitstream: any bands we choose to
361                skip here must be explicitly signaled.*/
362             /*Choose a threshold with some hysteresis to keep bands from
363                fluctuating in and out.*/
364             if (band_bits > ((j<prev?7:9)*band_width<<LM<<BITRES)>>4)
365             {
366                ec_enc_bit_logp((ec_enc *)ec, 1, 1);
367                break;
368             }
369             ec_enc_bit_logp((ec_enc *)ec, 0, 1);
370          } else if (ec_dec_bit_logp((ec_dec *)ec, 1)) {
371             break;
372          }
373          /*We used a bit to skip this band.*/
374          psum += 1<<BITRES;
375          band_bits -= 1<<BITRES;
376       }
377       /*Reclaim the bits originally allocated to this band.*/
378       psum -= bits[j]+intensity_rsv;
379       if (intensity_rsv > 0)
380          intensity_rsv = LOG2_FRAC_TABLE[j-start];
381       psum += intensity_rsv;
382       if (band_bits >= alloc_floor)
383       {
384          /*If we have enough for a fine energy bit per channel, use it.*/
385          psum += alloc_floor;
386          bits[j] = alloc_floor;
387       } else {
388          /*Otherwise this band gets nothing at all.*/
389          bits[j] = 0;
390       }
391    }
392
393    celt_assert(codedBands > start);
394    /* Code the intensity and dual stereo parameters. */
395    if (intensity_rsv > 0)
396    {
397       if (encode)
398       {
399          *intensity = IMIN(*intensity, codedBands);
400          ec_enc_uint((ec_enc *)ec, *intensity-start, codedBands+1-start);
401       }
402       else
403          *intensity = start+ec_dec_uint((ec_dec *)ec, codedBands+1-start);
404    }
405    else
406       *intensity = 0;
407    if (*intensity <= start)
408    {
409       total += dual_stereo_rsv;
410       dual_stereo_rsv = 0;
411    }
412    if (dual_stereo_rsv > 0)
413    {
414       if (encode)
415          ec_enc_bit_logp((ec_enc *)ec, *dual_stereo, 1);
416       else
417          *dual_stereo = ec_dec_bit_logp((ec_dec *)ec, 1);
418    }
419    else
420       *dual_stereo = 0;
421
422    /* Allocate the remaining bits */
423    left = total-psum;
424    percoeff = left/(m->eBands[codedBands]-m->eBands[start]);
425    left -= (m->eBands[codedBands]-m->eBands[start])*percoeff;
426    for (j=start;j<codedBands;j++)
427       bits[j] += percoeff*(m->eBands[j+1]-m->eBands[j]);
428    for (j=start;j<codedBands;j++)
429    {
430       int tmp = IMIN(left, m->eBands[j+1]-m->eBands[j]);
431       bits[j] += tmp;
432       left -= tmp;
433    }
434    /*for (j=0;j<end;j++)printf("%d ", bits[j]);printf("\n");*/
435
436    balance = 0;
437    for (j=start;j<codedBands;j++)
438    {
439       int N0, N, den;
440       int offset;
441       int NClogN;
442
443       celt_assert(bits[j] >= 0);
444       N0 = m->eBands[j+1]-m->eBands[j];
445       N=N0<<LM;
446
447       if (N>1)
448       {
449          /* Compensate for the extra DoF in stereo */
450          den=(C*N+ ((C==2 && N>2) ? 1 : 0));
451
452          NClogN = den*(m->logN[j] + logM);
453
454          /* Offset for the number of fine bits by log2(N)/2 + FINE_OFFSET
455             compared to their "fair share" of total/N */
456          offset = (NClogN>>1)-den*FINE_OFFSET;
457
458          /* N=2 is the only point that doesn't match the curve */
459          if (N==2)
460             offset += den<<BITRES>>2;
461
462          /* Changing the offset for allocating the second and third
463              fine energy bit */
464          if (bits[j] + offset < den*2<<BITRES)
465             offset += NClogN>>2;
466          else if (bits[j] + offset < den*3<<BITRES)
467             offset += NClogN>>3;
468
469          /* Divide with rounding */
470          ebits[j] = IMAX(0, (bits[j] + offset + (den<<(BITRES-1))) / (den<<BITRES));
471
472          /* Make sure not to bust */
473          if (C*ebits[j] > (bits[j]>>BITRES))
474             ebits[j] = bits[j] >> stereo >> BITRES;
475
476          /* More than that is useless because that's about as far as PVQ can go */
477          ebits[j] = IMIN(ebits[j], MAX_FINE_BITS);
478
479          /* If we rounded down or capped this band, make it a candidate for the
480              final fine energy pass */
481          fine_priority[j] = ebits[j]*(den<<BITRES) >= bits[j]+offset;
482
483       } else {
484          /* For N=1, all bits go to fine energy except for a single sign bit */
485          ebits[j] = IMIN(IMAX(0,(bits[j] >> stereo >> BITRES)-1),MAX_FINE_BITS);
486          fine_priority[j] = (ebits[j]+1)*C<<BITRES >= (bits[j]-balance);
487          /* N=1 bands can't take advantage of the re-balancing in
488              quant_all_bands() because they don't have shape, only fine energy.
489             Instead, do the re-balancing here.*/
490          balance = IMAX(0,bits[j] - ((ebits[j]+1)*C<<BITRES));
491          if (j+1<codedBands)
492          {
493             bits[j] -= balance;
494             bits[j+1] += balance;
495          }
496       }
497
498       /* Sweep any bits over the cap into the first band.
499          They'll be reallocated by the normal rebalancing code, which gives
500           them the best chance to be used _somewhere_. */
501       {
502          int tmp = IMAX(bits[j]-cap[j],0);
503          bits[j] -= tmp;
504          bits[start] += tmp;
505       }
506
507       /* Remove the allocated fine bits; the other bits are assigned to PVQ */
508       bits[j] -= C*ebits[j]<<BITRES;
509       celt_assert(bits[j] >= 0);
510       celt_assert(ebits[j] >= 0);
511    }
512    /* The skipped bands use all their bits for fine energy. */
513    for (;j<end;j++)
514    {
515       ebits[j] = bits[j] >> stereo >> BITRES;
516       celt_assert(C*ebits[j]<<BITRES == bits[j]);
517       bits[j] = 0;
518       fine_priority[j] = ebits[j]<1;
519    }
520    RESTORE_STACK;
521    return codedBands;
522 }
523
524 int compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stereo,
525       int total, int *pulses, int *ebits, int *fine_priority, int _C, int LM, void *ec, int encode, int prev)
526 {
527    int lo, hi, len, j;
528    const int C = CHANNELS(_C);
529    int codedBands;
530    int skip_start;
531    int skip_rsv;
532    int intensity_rsv;
533    int dual_stereo_rsv;
534    VARDECL(int, bits1);
535    VARDECL(int, bits2);
536    VARDECL(int, thresh);
537    VARDECL(int, trim_offset);
538    SAVE_STACK;
539    
540    total = IMAX(total, 0);
541    len = m->nbEBands;
542    skip_start = start;
543    /* Reserve a bit to signal the end of manually skipped bands. */
544    skip_rsv = total >= 1<<BITRES ? 1<<BITRES : 0;
545    total -= skip_rsv;
546    /* Reserve bits for the intensity and dual stereo parameters. */
547    intensity_rsv = dual_stereo_rsv = 0;
548    if (C==2)
549    {
550       intensity_rsv = LOG2_FRAC_TABLE[end-start];
551       if (intensity_rsv>total)
552          intensity_rsv = 0;
553       else
554       {
555          total -= intensity_rsv;
556          dual_stereo_rsv = total>=1<<BITRES ? 1<<BITRES : 0;
557          total -= dual_stereo_rsv;
558       }
559    }
560    ALLOC(bits1, len, int);
561    ALLOC(bits2, len, int);
562    ALLOC(thresh, len, int);
563    ALLOC(trim_offset, len, int);
564
565    for (j=start;j<end;j++)
566    {
567       /* Below this threshold, we're sure not to allocate any PVQ bits */
568       thresh[j] = IMAX((C)<<BITRES, (3*(m->eBands[j+1]-m->eBands[j])<<LM<<BITRES)>>4);
569       /* Tilt of the allocation curve */
570       trim_offset[j] = C*(m->eBands[j+1]-m->eBands[j])*(alloc_trim-5-LM)*(m->nbEBands-j-1)
571             <<(LM+BITRES)>>6;
572       /* Giving less resolution to single-coefficient bands because they get
573          more benefit from having one coarse value per coefficient*/
574       if ((m->eBands[j+1]-m->eBands[j])<<LM==1)
575          trim_offset[j] -= C<<BITRES;
576    }
577    lo = 1;
578    hi = m->nbAllocVectors - 2;
579    do
580    {
581       int done = 0;
582       int psum = 0;
583       int mid = (lo+hi) >> 1;
584       for (j=end;j-->start;)
585       {
586          int N = m->eBands[j+1]-m->eBands[j];
587          bits1[j] = C*N*m->allocVectors[mid*len+j]<<LM>>2;
588          if (bits1[j] > 0)
589             bits1[j] = IMAX(0, bits1[j] + trim_offset[j]);
590          bits1[j] += offsets[j];
591          if (bits1[j] >= thresh[j] || done)
592          {
593             done = 1;
594             /* Don't allocate more than we can actually use */
595             psum += IMIN(bits1[j], cap[j]);
596          } else {
597             if (bits1[j] >= C<<BITRES)
598                psum += C<<BITRES;
599          }
600       }
601       if (psum > total)
602          hi = mid - 1;
603       else
604          lo = mid + 1;
605       /*printf ("lo = %d, hi = %d\n", lo, hi);*/
606    }
607    while (lo <= hi);
608    hi = lo--;
609    /*printf ("interp between %d and %d\n", lo, hi);*/
610    for (j=start;j<end;j++)
611    {
612       int N = m->eBands[j+1]-m->eBands[j];
613       bits1[j] = C*N*m->allocVectors[lo*len+j]<<LM>>2;
614       bits2[j] = C*N*m->allocVectors[hi*len+j]<<LM>>2;
615       if (bits1[j] > 0)
616          bits1[j] = IMAX(0, bits1[j] + trim_offset[j]);
617       if (bits2[j] > 0)
618          bits2[j] = IMAX(0, bits2[j] + trim_offset[j]);
619       if (lo > 0)
620          bits1[j] += offsets[j];
621       bits2[j] += offsets[j];
622       if (offsets[j]>0)
623          skip_start = j;
624       bits2[j] -= bits1[j];
625    }
626    codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap,
627          total, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv,
628          pulses, ebits, fine_priority, C, LM, ec, encode, prev);
629    RESTORE_STACK;
630    return codedBands;
631 }
632