Adds 3rd clause to CELT license
[opus.git] / celt / 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 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 <math.h>
39 #include "modes.h"
40 #include "cwrs.h"
41 #include "arch.h"
42 #include "os_support.h"
43
44 #include "entcode.h"
45 #include "rate.h"
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 #ifdef CUSTOM_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 opus_int16 maxN[15] = {
62       32767, 32767, 32767, 1476, 283, 109,  60,  40,
63        29,  24,  20,  18,  16,  14,  13};
64    static const opus_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 opus_int16 *eBands = m->eBands;
87    PulseCache *cache = &m->cache;
88    opus_int16 *cindex;
89    unsigned char *bits;
90    unsigned char *cap;
91
92    cindex = opus_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 = opus_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       opus_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 = opus_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          for (j=0;j<m->nbEBands;j++)
154          {
155             int N0;
156             int max_bits;
157             N0 = m->eBands[j+1]-m->eBands[j];
158             /* N=1 bands only have a sign bit and fine bits. */
159             if (N0<<i == 1)
160                max_bits = C*(1+MAX_FINE_BITS)<<BITRES;
161             else
162             {
163                const unsigned char *pcache;
164                opus_int32           num;
165                opus_int32           den;
166                int                  LM0;
167                int                  N;
168                int                  offset;
169                int                  ndof;
170                int                  qb;
171                int                  k;
172                LM0 = 0;
173                /* Even-sized bands bigger than N=2 can be split one more time.
174                   As of commit 44203907 all bands >1 are even, including custom modes.*/
175                if (N0 > 2)
176                {
177                   N0>>=1;
178                   LM0--;
179                }
180                /* N0=1 bands can't be split down to N<2. */
181                else if (N0 <= 1)
182                {
183                   LM0=IMIN(i,1);
184                   N0<<=LM0;
185                }
186                /* Compute the cost for the lowest-level PVQ of a fully split
187                    band. */
188                pcache = bits + cindex[(LM0+1)*m->nbEBands+j];
189                max_bits = pcache[pcache[0]]+1;
190                /* Add in the cost of coding regular splits. */
191                N = N0;
192                for(k=0;k<i-LM0;k++){
193                   max_bits <<= 1;
194                   /* Offset the number of qtheta bits by log2(N)/2
195                       + QTHETA_OFFSET compared to their "fair share" of
196                       total/N */
197                   offset = ((m->logN[j]+((LM0+k)<<BITRES))>>1)-QTHETA_OFFSET;
198                   /* The number of qtheta bits we'll allocate if the remainder
199                       is to be max_bits.
200                      The average measured cost for theta is 0.89701 times qb,
201                       approximated here as 459/512. */
202                   num=459*(opus_int32)((2*N-1)*offset+max_bits);
203                   den=((opus_int32)(2*N-1)<<9)-459;
204                   qb = IMIN((num+(den>>1))/den, 57);
205                   celt_assert(qb >= 0);
206                   max_bits += qb;
207                   N <<= 1;
208                }
209                /* Add in the cost of a stereo split, if necessary. */
210                if (C==2)
211                {
212                   max_bits <<= 1;
213                   offset = ((m->logN[j]+(i<<BITRES))>>1)-(N==2?QTHETA_OFFSET_TWOPHASE:QTHETA_OFFSET);
214                   ndof = 2*N-1-(N==2);
215                   /* The average measured cost for theta with the step PDF is
216                       0.95164 times qb, approximated here as 487/512. */
217                   num = (N==2?512:487)*(opus_int32)(max_bits+ndof*offset);
218                   den = ((opus_int32)ndof<<9)-(N==2?512:487);
219                   qb = IMIN((num+(den>>1))/den, (N==2?64:61));
220                   celt_assert(qb >= 0);
221                   max_bits += qb;
222                }
223                /* Add the fine bits we'll use. */
224                /* Compensate for the extra DoF in stereo */
225                ndof = C*N + ((C==2 && N>2) ? 1 : 0);
226                /* Offset the number of fine bits by log2(N)/2 + FINE_OFFSET
227                    compared to their "fair share" of total/N */
228                offset = ((m->logN[j] + (i<<BITRES))>>1)-FINE_OFFSET;
229                /* N=2 is the only point that doesn't match the curve */
230                if (N==2)
231                   offset += 1<<BITRES>>2;
232                /* The number of fine bits we'll allocate if the remainder is
233                    to be max_bits. */
234                num = max_bits+ndof*offset;
235                den = (ndof-1)<<BITRES;
236                qb = IMIN((num+(den>>1))/den, MAX_FINE_BITS);
237                celt_assert(qb >= 0);
238                max_bits += C*qb<<BITRES;
239             }
240             max_bits = (4*max_bits/(C*((m->eBands[j+1]-m->eBands[j])<<i)))-64;
241             celt_assert(max_bits >= 0);
242             celt_assert(max_bits < 256);
243             *cap++ = (unsigned char)max_bits;
244          }
245       }
246    }
247 }
248
249 #endif /* CUSTOM_MODES */
250
251 #define ALLOC_STEPS 6
252
253 static inline int interp_bits2pulses(const CELTMode *m, int start, int end, int skip_start,
254       const int *bits1, const int *bits2, const int *thresh, const int *cap, opus_int32 total, opus_int32 *_balance,
255       int skip_rsv, int *intensity, int intensity_rsv, int *dual_stereo, int dual_stereo_rsv, int *bits,
256       int *ebits, int *fine_priority, int C, int LM, ec_ctx *ec, int encode, int prev)
257 {
258    opus_int32 psum;
259    int lo, hi;
260    int i, j;
261    int logM;
262    int stereo;
263    int codedBands=-1;
264    int alloc_floor;
265    opus_int32 left, percoeff;
266    int done;
267    int balance;
268    SAVE_STACK;
269
270    alloc_floor = C<<BITRES;
271    stereo = C>1;
272
273    logM = LM<<BITRES;
274    lo = 0;
275    hi = 1<<ALLOC_STEPS;
276    for (i=0;i<ALLOC_STEPS;i++)
277    {
278       int mid = (lo+hi)>>1;
279       psum = 0;
280       done = 0;
281       for (j=end;j-->start;)
282       {
283          int tmp = bits1[j] + (mid*(opus_int32)bits2[j]>>ALLOC_STEPS);
284          if (tmp >= thresh[j] || done)
285          {
286             done = 1;
287             /* Don't allocate more than we can actually use */
288             psum += IMIN(tmp, cap[j]);
289          } else {
290             if (tmp >= alloc_floor)
291                psum += alloc_floor;
292          }
293       }
294       if (psum > total)
295          hi = mid;
296       else
297          lo = mid;
298    }
299    psum = 0;
300    /*printf ("interp bisection gave %d\n", lo);*/
301    done = 0;
302    for (j=end;j-->start;)
303    {
304       int tmp = bits1[j] + (lo*bits2[j]>>ALLOC_STEPS);
305       if (tmp < thresh[j] && !done)
306       {
307          if (tmp >= alloc_floor)
308             tmp = alloc_floor;
309          else
310             tmp = 0;
311       } else
312          done = 1;
313       /* Don't allocate more than we can actually use */
314       tmp = IMIN(tmp, cap[j]);
315       bits[j] = tmp;
316       psum += tmp;
317    }
318
319    /* Decide which bands to skip, working backwards from the end. */
320    for (codedBands=end;;codedBands--)
321    {
322       int band_width;
323       int band_bits;
324       int rem;
325       j = codedBands-1;
326       /* Never skip the first band, nor a band that has been boosted by
327           dynalloc.
328          In the first case, we'd be coding a bit to signal we're going to waste
329           all the other bits.
330          In the second case, we'd be coding a bit to redistribute all the bits
331           we just signaled should be cocentrated in this band. */
332       if (j<=skip_start)
333       {
334          /* Give the bit we reserved to end skipping back. */
335          total += skip_rsv;
336          break;
337       }
338       /*Figure out how many left-over bits we would be adding to this band.
339         This can include bits we've stolen back from higher, skipped bands.*/
340       left = total-psum;
341       percoeff = left/(m->eBands[codedBands]-m->eBands[start]);
342       left -= (m->eBands[codedBands]-m->eBands[start])*percoeff;
343       rem = IMAX(left-(m->eBands[j]-m->eBands[start]),0);
344       band_width = m->eBands[codedBands]-m->eBands[j];
345       band_bits = (int)(bits[j] + percoeff*band_width + rem);
346       /*Only code a skip decision if we're above the threshold for this band.
347         Otherwise it is force-skipped.
348         This ensures that we have enough bits to code the skip flag.*/
349       if (band_bits >= IMAX(thresh[j], alloc_floor+(1<<BITRES)))
350       {
351          if (encode)
352          {
353             /*This if() block is the only part of the allocation function that
354                is not a mandatory part of the bitstream: any bands we choose to
355                skip here must be explicitly signaled.*/
356             /*Choose a threshold with some hysteresis to keep bands from
357                fluctuating in and out.*/
358 #ifdef FUZZING
359             if ((rand()&0x1) == 0)
360 #else
361             if (band_bits > ((j<prev?7:9)*band_width<<LM<<BITRES)>>4)
362 #endif
363             {
364                ec_enc_bit_logp(ec, 1, 1);
365                break;
366             }
367             ec_enc_bit_logp(ec, 0, 1);
368          } else if (ec_dec_bit_logp(ec, 1)) {
369             break;
370          }
371          /*We used a bit to skip this band.*/
372          psum += 1<<BITRES;
373          band_bits -= 1<<BITRES;
374       }
375       /*Reclaim the bits originally allocated to this band.*/
376       psum -= bits[j]+intensity_rsv;
377       if (intensity_rsv > 0)
378          intensity_rsv = LOG2_FRAC_TABLE[j-start];
379       psum += intensity_rsv;
380       if (band_bits >= alloc_floor)
381       {
382          /*If we have enough for a fine energy bit per channel, use it.*/
383          psum += alloc_floor;
384          bits[j] = alloc_floor;
385       } else {
386          /*Otherwise this band gets nothing at all.*/
387          bits[j] = 0;
388       }
389    }
390
391    celt_assert(codedBands > start);
392    /* Code the intensity and dual stereo parameters. */
393    if (intensity_rsv > 0)
394    {
395       if (encode)
396       {
397          *intensity = IMIN(*intensity, codedBands);
398          ec_enc_uint(ec, *intensity-start, codedBands+1-start);
399       }
400       else
401          *intensity = start+ec_dec_uint(ec, codedBands+1-start);
402    }
403    else
404       *intensity = 0;
405    if (*intensity <= start)
406    {
407       total += dual_stereo_rsv;
408       dual_stereo_rsv = 0;
409    }
410    if (dual_stereo_rsv > 0)
411    {
412       if (encode)
413          ec_enc_bit_logp(ec, *dual_stereo, 1);
414       else
415          *dual_stereo = ec_dec_bit_logp(ec, 1);
416    }
417    else
418       *dual_stereo = 0;
419
420    /* Allocate the remaining bits */
421    left = total-psum;
422    percoeff = left/(m->eBands[codedBands]-m->eBands[start]);
423    left -= (m->eBands[codedBands]-m->eBands[start])*percoeff;
424    for (j=start;j<codedBands;j++)
425       bits[j] += ((int)percoeff*(m->eBands[j+1]-m->eBands[j]));
426    for (j=start;j<codedBands;j++)
427    {
428       int tmp = (int)IMIN(left, m->eBands[j+1]-m->eBands[j]);
429       bits[j] += tmp;
430       left -= tmp;
431    }
432    /*for (j=0;j<end;j++)printf("%d ", bits[j]);printf("\n");*/
433
434    balance = 0;
435    for (j=start;j<codedBands;j++)
436    {
437       int N0, N, den;
438       int offset;
439       int NClogN;
440       int excess;
441
442       celt_assert(bits[j] >= 0);
443       N0 = m->eBands[j+1]-m->eBands[j];
444       N=N0<<LM;
445       bits[j] += balance;
446
447       if (N>1)
448       {
449          excess = IMAX(bits[j]-cap[j],0);
450          bits[j] -= excess;
451
452          /* Compensate for the extra DoF in stereo */
453          den=(C*N+ ((C==2 && N>2 && !*dual_stereo && j<*intensity) ? 1 : 0));
454
455          NClogN = den*(m->logN[j] + logM);
456
457          /* Offset for the number of fine bits by log2(N)/2 + FINE_OFFSET
458             compared to their "fair share" of total/N */
459          offset = (NClogN>>1)-den*FINE_OFFSET;
460
461          /* N=2 is the only point that doesn't match the curve */
462          if (N==2)
463             offset += den<<BITRES>>2;
464
465          /* Changing the offset for allocating the second and third
466              fine energy bit */
467          if (bits[j] + offset < den*2<<BITRES)
468             offset += NClogN>>2;
469          else if (bits[j] + offset < den*3<<BITRES)
470             offset += NClogN>>3;
471
472          /* Divide with rounding */
473          ebits[j] = IMAX(0, (bits[j] + offset + (den<<(BITRES-1))) / (den<<BITRES));
474
475          /* Make sure not to bust */
476          if (C*ebits[j] > (bits[j]>>BITRES))
477             ebits[j] = bits[j] >> stereo >> BITRES;
478
479          /* More than that is useless because that's about as far as PVQ can go */
480          ebits[j] = IMIN(ebits[j], MAX_FINE_BITS);
481
482          /* If we rounded down or capped this band, make it a candidate for the
483              final fine energy pass */
484          fine_priority[j] = ebits[j]*(den<<BITRES) >= bits[j]+offset;
485
486          /* Remove the allocated fine bits; the rest are assigned to PVQ */
487          bits[j] -= C*ebits[j]<<BITRES;
488
489       } else {
490          /* For N=1, all bits go to fine energy except for a single sign bit */
491          excess = IMAX(0,bits[j]-(C<<BITRES));
492          bits[j] -= excess;
493          ebits[j] = 0;
494          fine_priority[j] = 1;
495       }
496
497       /* Fine energy can't take advantage of the re-balancing in
498           quant_all_bands().
499          Instead, do the re-balancing here.*/
500       if(excess > 0)
501       {
502          int extra_fine;
503          int extra_bits;
504          extra_fine = IMIN(excess>>(stereo+BITRES),MAX_FINE_BITS-ebits[j]);
505          ebits[j] += extra_fine;
506          extra_bits = extra_fine*C<<BITRES;
507          fine_priority[j] = extra_bits >= excess-balance;
508          excess -= extra_bits;
509       }
510       balance = excess;
511
512       celt_assert(bits[j] >= 0);
513       celt_assert(ebits[j] >= 0);
514    }
515    /* Save any remaining bits over the cap for the rebalancing in
516        quant_all_bands(). */
517    *_balance = balance;
518
519    /* The skipped bands use all their bits for fine energy. */
520    for (;j<end;j++)
521    {
522       ebits[j] = bits[j] >> stereo >> BITRES;
523       celt_assert(C*ebits[j]<<BITRES == bits[j]);
524       bits[j] = 0;
525       fine_priority[j] = ebits[j]<1;
526    }
527    RESTORE_STACK;
528    return codedBands;
529 }
530
531 int compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stereo,
532       opus_int32 total, opus_int32 *balance, int *pulses, int *ebits, int *fine_priority, int C, int LM, ec_ctx *ec, int encode, int prev)
533 {
534    int lo, hi, len, j;
535    int codedBands;
536    int skip_start;
537    int skip_rsv;
538    int intensity_rsv;
539    int dual_stereo_rsv;
540    VARDECL(int, bits1);
541    VARDECL(int, bits2);
542    VARDECL(int, thresh);
543    VARDECL(int, trim_offset);
544    SAVE_STACK;
545
546    total = IMAX(total, 0);
547    len = m->nbEBands;
548    skip_start = start;
549    /* Reserve a bit to signal the end of manually skipped bands. */
550    skip_rsv = total >= 1<<BITRES ? 1<<BITRES : 0;
551    total -= skip_rsv;
552    /* Reserve bits for the intensity and dual stereo parameters. */
553    intensity_rsv = dual_stereo_rsv = 0;
554    if (C==2)
555    {
556       intensity_rsv = LOG2_FRAC_TABLE[end-start];
557       if (intensity_rsv>total)
558          intensity_rsv = 0;
559       else
560       {
561          total -= intensity_rsv;
562          dual_stereo_rsv = total>=1<<BITRES ? 1<<BITRES : 0;
563          total -= dual_stereo_rsv;
564       }
565    }
566    ALLOC(bits1, len, int);
567    ALLOC(bits2, len, int);
568    ALLOC(thresh, len, int);
569    ALLOC(trim_offset, len, int);
570
571    for (j=start;j<end;j++)
572    {
573       /* Below this threshold, we're sure not to allocate any PVQ bits */
574       thresh[j] = IMAX((C)<<BITRES, (3*(m->eBands[j+1]-m->eBands[j])<<LM<<BITRES)>>4);
575       /* Tilt of the allocation curve */
576       trim_offset[j] = C*(m->eBands[j+1]-m->eBands[j])*(alloc_trim-5-LM)*(end-j-1)
577             *(1<<(LM+BITRES))>>6;
578       /* Giving less resolution to single-coefficient bands because they get
579          more benefit from having one coarse value per coefficient*/
580       if ((m->eBands[j+1]-m->eBands[j])<<LM==1)
581          trim_offset[j] -= C<<BITRES;
582    }
583    lo = 1;
584    hi = m->nbAllocVectors - 1;
585    do
586    {
587       int done = 0;
588       int psum = 0;
589       int mid = (lo+hi) >> 1;
590       for (j=end;j-->start;)
591       {
592          int bitsj;
593          int N = m->eBands[j+1]-m->eBands[j];
594          bitsj = C*N*m->allocVectors[mid*len+j]<<LM>>2;
595          if (bitsj > 0)
596             bitsj = IMAX(0, bitsj + trim_offset[j]);
597          bitsj += offsets[j];
598          if (bitsj >= thresh[j] || done)
599          {
600             done = 1;
601             /* Don't allocate more than we can actually use */
602             psum += IMIN(bitsj, cap[j]);
603          } else {
604             if (bitsj >= C<<BITRES)
605                psum += C<<BITRES;
606          }
607       }
608       if (psum > total)
609          hi = mid - 1;
610       else
611          lo = mid + 1;
612       /*printf ("lo = %d, hi = %d\n", lo, hi);*/
613    }
614    while (lo <= hi);
615    hi = lo--;
616    /*printf ("interp between %d and %d\n", lo, hi);*/
617    for (j=start;j<end;j++)
618    {
619       int bits1j, bits2j;
620       int N = m->eBands[j+1]-m->eBands[j];
621       bits1j = C*N*m->allocVectors[lo*len+j]<<LM>>2;
622       bits2j = hi>=m->nbAllocVectors ?
623             cap[j] : C*N*m->allocVectors[hi*len+j]<<LM>>2;
624       if (bits1j > 0)
625          bits1j = IMAX(0, bits1j + trim_offset[j]);
626       if (bits2j > 0)
627          bits2j = IMAX(0, bits2j + trim_offset[j]);
628       if (lo > 0)
629          bits1j += offsets[j];
630       bits2j += offsets[j];
631       if (offsets[j]>0)
632          skip_start = j;
633       bits2j = IMAX(0,bits2j-bits1j);
634       bits1[j] = bits1j;
635       bits2[j] = bits2j;
636    }
637    codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap,
638          total, balance, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv,
639          pulses, ebits, fine_priority, C, LM, ec, encode, prev);
640    RESTORE_STACK;
641    return codedBands;
642 }
643