6023459c129991652bb4d64d2f6dce95c9ae3585
[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 #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 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             N0 = m->eBands[j+1]-m->eBands[j];
160             /* N=1 bands only have a sign bit and fine bits. */
161             if (N0<<i == 1)
162                max_bits = C*(1+MAX_FINE_BITS)<<BITRES;
163             else
164             {
165                const unsigned char *pcache;
166                celt_int32           num;
167                celt_int32           den;
168                int                  LM0;
169                int                  N;
170                int                  offset;
171                int                  ndof;
172                int                  qb;
173                int                  k;
174                LM0 = 0;
175                /* Even-sized bands bigger than N=4 can be split one more
176                    time (N=4 also _can_ be split, but not without waste: the
177                    result can only use 26 bits, but requires an allocation
178                    of 32 to trigger the split). */
179                if (N0 > 4 && !(N0&1))
180                {
181                   N0>>=1;
182                   LM0--;
183                }
184                /* N0=1 and N0=2 bands can't be split down to N=2. */
185                else if (N0 <= 2)
186                {
187                   LM0=IMIN(i,3-N0);
188                   N0<<=LM0;
189                }
190                /* Compute the cost for the lowest-level PVQ of a fully split
191                    band. */
192                pcache = bits + cindex[(LM0+1)*m->nbEBands+j];
193                max_bits = pcache[pcache[0]]+1;
194                /* Add in the cost of coding regular splits. */
195                N = N0;
196                for(k=0;k<i-LM0;k++){
197                   max_bits <<= 1;
198                   /* Offset the number of qtheta bits by log2(N)/2
199                       + QTHETA_OFFSET compared to their "fair share" of
200                       total/N */
201                   offset = (m->logN[j]+(LM0+k<<BITRES)>>1)-QTHETA_OFFSET;
202                   /* The number of qtheta bits we'll allocate if the remainder
203                       is to be max_bits.
204                      The average measured cost for theta is 0.89701 times qb,
205                       approximated here as 459/512. */
206                   num=459*(celt_int32)((2*N-1)*offset+max_bits);
207                   den=((celt_int32)(2*N-1)<<9)-459;
208                   qb = IMIN((num+(den>>1))/den, 57);
209                   celt_assert(qb >= 0);
210                   max_bits += qb;
211                   N <<= 1;
212                }
213                /* Add in the cost of a stereo split, if necessary. */
214                if (C==2)
215                {
216                   max_bits <<= 1;
217                   offset = (m->logN[j]+(i<<BITRES)>>1)-QTHETA_OFFSET_STEREO;
218                   ndof = 2*N-1-(N==2);
219                   /* The average measured cost for theta with the step PDF is
220                       0.95164 times qb, approximated here as 487/512. */
221                   num = (N==2?512:487)*(celt_int32)(max_bits+ndof*offset);
222                   den = ((celt_int32)ndof<<9)-(N==2?512:487);
223                   qb = IMIN((num+(den>>1))/den, (N==2?64:61));
224                   celt_assert(qb >= 0);
225                   max_bits += qb;
226                }
227                /* Add the fine bits we'll use. */
228                /* Compensate for the extra DoF in stereo */
229                ndof = C*N + ((C==2 && N>2) ? 1 : 0);
230                /* Offset the number of fine bits by log2(N)/2 + FINE_OFFSET
231                    compared to their "fair share" of total/N */
232                offset = (m->logN[j] + (i<<BITRES)>>1)-FINE_OFFSET;
233                /* N=2 is the only point that doesn't match the curve */
234                if (N==2)
235                   offset += 1<<BITRES>>2;
236                /* The number of fine bits we'll allocate if the remainder is
237                    to be max_bits. */
238                num = max_bits+ndof*offset;
239                den = ndof-1<<BITRES;
240                qb = IMIN((num+(den>>1))/den, MAX_FINE_BITS);
241                celt_assert(qb >= 0);
242                max_bits += C*qb<<BITRES;
243             }
244             celt_assert(max_bits>>shift < 256);
245             *cap++ = (unsigned char)(max_bits>>shift);
246          }
247       }
248    }
249 }
250
251 #endif /* CUSTOM_MODES */
252
253
254 #define ALLOC_STEPS 6
255
256 static inline int interp_bits2pulses(const CELTMode *m, int start, int end, int skip_start,
257       const int *bits1, const int *bits2, const int *thresh, const int *cap, int total, int skip_rsv,
258       int *intensity, int intensity_rsv, int *dual_stereo, int dual_stereo_rsv, int *bits,
259       int *ebits, int *fine_priority, int _C, int LM, void *ec, int encode, int prev)
260 {
261    int psum;
262    int lo, hi;
263    int i, j;
264    int logM;
265    const int C = CHANNELS(_C);
266    int stereo;
267    int codedBands=-1;
268    int alloc_floor;
269    int left, percoeff;
270    int done;
271    int balance;
272    SAVE_STACK;
273
274    alloc_floor = C<<BITRES;
275    stereo = C>1;
276
277    logM = LM<<BITRES;
278    lo = 0;
279    hi = 1<<ALLOC_STEPS;
280    for (i=0;i<ALLOC_STEPS;i++)
281    {
282       int mid = (lo+hi)>>1;
283       psum = 0;
284       done = 0;
285       for (j=end;j-->start;)
286       {
287          int tmp = bits1[j] + (mid*bits2[j]>>ALLOC_STEPS);
288          if (tmp >= thresh[j] || done)
289          {
290             done = 1;
291             /* Don't allocate more than we can actually use */
292             psum += IMIN(tmp, cap[j]);
293          } else {
294             if (tmp >= alloc_floor)
295                psum += alloc_floor;
296          }
297       }
298       if (psum > total)
299          hi = mid;
300       else
301          lo = mid;
302    }
303    psum = 0;
304    /*printf ("interp bisection gave %d\n", lo);*/
305    done = 0;
306    for (j=end;j-->start;)
307    {
308       int tmp = bits1[j] + (lo*bits2[j]>>ALLOC_STEPS);
309       if (tmp < thresh[j] && !done)
310       {
311          if (tmp >= alloc_floor)
312             tmp = alloc_floor;
313          else
314             tmp = 0;
315       } else
316          done = 1;
317       /* Don't allocate more than we can actually use */
318       tmp = IMIN(tmp, cap[j]);
319       bits[j] = tmp;
320       psum += tmp;
321    }
322
323    /* Decide which bands to skip, working backwards from the end. */
324    for (codedBands=end;;codedBands--)
325    {
326       int band_width;
327       int band_bits;
328       int rem;
329       j = codedBands-1;
330       /* Never skip the first band, nor a band that has been boosted by
331           dynalloc.
332          In the first case, we'd be coding a bit to signal we're going to waste
333           all the other bits.
334          In the second case, we'd be coding a bit to redistribute all the bits
335           we just signaled should be cocentrated in this band. */
336       if (j<=skip_start)
337       {
338          /* Give the bit we reserved to end skipping back. */
339          total += skip_rsv;
340          break;
341       }
342       /*Figure out how many left-over bits we would be adding to this band.
343         This can include bits we've stolen back from higher, skipped bands.*/
344       left = total-psum;
345       percoeff = left/(m->eBands[codedBands]-m->eBands[start]);
346       left -= (m->eBands[codedBands]-m->eBands[start])*percoeff;
347       rem = IMAX(left-(m->eBands[j]-m->eBands[start]),0);
348       band_width = m->eBands[codedBands]-m->eBands[j];
349       band_bits = bits[j] + percoeff*band_width + rem;
350       /*Only code a skip decision if we're above the threshold for this band.
351         Otherwise it is force-skipped.
352         This ensures that we have enough bits to code the skip flag.*/
353       if (band_bits >= IMAX(thresh[j], alloc_floor+(1<<BITRES)))
354       {
355          if (encode)
356          {
357             /*This if() block is the only part of the allocation function that
358                is not a mandatory part of the bitstream: any bands we choose to
359                skip here must be explicitly signaled.*/
360             /*Choose a threshold with some hysteresis to keep bands from
361                fluctuating in and out.*/
362             if (band_bits > ((j<prev?7:9)*band_width<<LM<<BITRES)>>4)
363             {
364                ec_enc_bit_logp((ec_enc *)ec, 1, 1);
365                break;
366             }
367             ec_enc_bit_logp((ec_enc *)ec, 0, 1);
368          } else if (ec_dec_bit_logp((ec_dec *)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_enc *)ec, *intensity-start, codedBands+1-start);
399       }
400       else
401          *intensity = start+ec_dec_uint((ec_dec *)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_enc *)ec, *dual_stereo, 1);
414       else
415          *dual_stereo = ec_dec_bit_logp((ec_dec *)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] += percoeff*(m->eBands[j+1]-m->eBands[j]);
426    for (j=start;j<codedBands;j++)
427    {
428       int tmp = 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) ? 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    /* Sweep any bits over the caps into the first band.
516       They'll be reallocated by the normal rebalancing code, which gives
517        them the best chance to be used _somewhere_. */
518    bits[start]+=balance;
519
520    /* The skipped bands use all their bits for fine energy. */
521    for (;j<end;j++)
522    {
523       ebits[j] = bits[j] >> stereo >> BITRES;
524       celt_assert(C*ebits[j]<<BITRES == bits[j]);
525       bits[j] = 0;
526       fine_priority[j] = ebits[j]<1;
527    }
528    RESTORE_STACK;
529    return codedBands;
530 }
531
532 int compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stereo,
533       int total, int *pulses, int *ebits, int *fine_priority, int _C, int LM, void *ec, int encode, int prev)
534 {
535    int lo, hi, len, j;
536    const int C = CHANNELS(_C);
537    int codedBands;
538    int skip_start;
539    int skip_rsv;
540    int intensity_rsv;
541    int dual_stereo_rsv;
542    VARDECL(int, bits1);
543    VARDECL(int, bits2);
544    VARDECL(int, thresh);
545    VARDECL(int, trim_offset);
546    SAVE_STACK;
547    
548    total = IMAX(total, 0);
549    len = m->nbEBands;
550    skip_start = start;
551    /* Reserve a bit to signal the end of manually skipped bands. */
552    skip_rsv = total >= 1<<BITRES ? 1<<BITRES : 0;
553    total -= skip_rsv;
554    /* Reserve bits for the intensity and dual stereo parameters. */
555    intensity_rsv = dual_stereo_rsv = 0;
556    if (C==2)
557    {
558       intensity_rsv = LOG2_FRAC_TABLE[end-start];
559       if (intensity_rsv>total)
560          intensity_rsv = 0;
561       else
562       {
563          total -= intensity_rsv;
564          dual_stereo_rsv = total>=1<<BITRES ? 1<<BITRES : 0;
565          total -= dual_stereo_rsv;
566       }
567    }
568    ALLOC(bits1, len, int);
569    ALLOC(bits2, len, int);
570    ALLOC(thresh, len, int);
571    ALLOC(trim_offset, len, int);
572
573    for (j=start;j<end;j++)
574    {
575       /* Below this threshold, we're sure not to allocate any PVQ bits */
576       thresh[j] = IMAX((C)<<BITRES, (3*(m->eBands[j+1]-m->eBands[j])<<LM<<BITRES)>>4);
577       /* Tilt of the allocation curve */
578       trim_offset[j] = C*(m->eBands[j+1]-m->eBands[j])*(alloc_trim-5-LM)*(m->nbEBands-j-1)
579             <<(LM+BITRES)>>6;
580       /* Giving less resolution to single-coefficient bands because they get
581          more benefit from having one coarse value per coefficient*/
582       if ((m->eBands[j+1]-m->eBands[j])<<LM==1)
583          trim_offset[j] -= C<<BITRES;
584    }
585    lo = 1;
586    hi = m->nbAllocVectors - 2;
587    do
588    {
589       int done = 0;
590       int psum = 0;
591       int mid = (lo+hi) >> 1;
592       for (j=end;j-->start;)
593       {
594          int N = m->eBands[j+1]-m->eBands[j];
595          bits1[j] = C*N*m->allocVectors[mid*len+j]<<LM>>2;
596          if (bits1[j] > 0)
597             bits1[j] = IMAX(0, bits1[j] + trim_offset[j]);
598          bits1[j] += offsets[j];
599          if (bits1[j] >= thresh[j] || done)
600          {
601             done = 1;
602             /* Don't allocate more than we can actually use */
603             psum += IMIN(bits1[j], cap[j]);
604          } else {
605             if (bits1[j] >= C<<BITRES)
606                psum += C<<BITRES;
607          }
608       }
609       if (psum > total)
610          hi = mid - 1;
611       else
612          lo = mid + 1;
613       /*printf ("lo = %d, hi = %d\n", lo, hi);*/
614    }
615    while (lo <= hi);
616    hi = lo--;
617    /*printf ("interp between %d and %d\n", lo, hi);*/
618    for (j=start;j<end;j++)
619    {
620       int N = m->eBands[j+1]-m->eBands[j];
621       bits1[j] = C*N*m->allocVectors[lo*len+j]<<LM>>2;
622       bits2[j] = C*N*m->allocVectors[hi*len+j]<<LM>>2;
623       if (bits1[j] > 0)
624          bits1[j] = IMAX(0, bits1[j] + trim_offset[j]);
625       if (bits2[j] > 0)
626          bits2[j] = IMAX(0, bits2[j] + trim_offset[j]);
627       if (lo > 0)
628          bits1[j] += offsets[j];
629       bits2[j] += offsets[j];
630       if (offsets[j]>0)
631          skip_start = j;
632       bits2[j] -= bits1[j];
633    }
634    codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap,
635          total, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv,
636          pulses, ebits, fine_priority, C, LM, ec, encode, prev);
637    RESTORE_STACK;
638    return codedBands;
639 }
640