Add missing include to the list
[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    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
20    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include <math.h>
34 #include "modes.h"
35 #include "cwrs.h"
36 #include "arch.h"
37 #include "os_support.h"
38
39 #include "entcode.h"
40 #include "rate.h"
41
42 static const unsigned char LOG2_FRAC_TABLE[24]={
43    0,
44    8,13,
45   16,19,21,23,
46   24,26,27,28,29,30,31,32,
47   32,33,34,34,35,36,36,37,37
48 };
49
50 #ifdef CUSTOM_MODES
51
52 /*Determines if V(N,K) fits in a 32-bit unsigned integer.
53   N and K are themselves limited to 15 bits.*/
54 static int fits_in32(int _n, int _k)
55 {
56    static const opus_int16 maxN[15] = {
57       32767, 32767, 32767, 1476, 283, 109,  60,  40,
58        29,  24,  20,  18,  16,  14,  13};
59    static const opus_int16 maxK[15] = {
60       32767, 32767, 32767, 32767, 1172, 238,  95,  53,
61        36,  27,  22,  18,  16,  15,  13};
62    if (_n>=14)
63    {
64       if (_k>=14)
65          return 0;
66       else
67          return _n <= maxN[_k];
68    } else {
69       return _k <= maxK[_n];
70    }
71 }
72
73 void compute_pulse_cache(CELTMode *m, int LM)
74 {
75    int C;
76    int i;
77    int j;
78    int curr=0;
79    int nbEntries=0;
80    int entryN[100], entryK[100], entryI[100];
81    const opus_int16 *eBands = m->eBands;
82    PulseCache *cache = &m->cache;
83    opus_int16 *cindex;
84    unsigned char *bits;
85    unsigned char *cap;
86
87    cindex = (opus_int16 *)opus_alloc(sizeof(cache->index[0])*m->nbEBands*(LM+2));
88    cache->index = cindex;
89
90    /* Scan for all unique band sizes */
91    for (i=0;i<=LM+1;i++)
92    {
93       for (j=0;j<m->nbEBands;j++)
94       {
95          int k;
96          int N = (eBands[j+1]-eBands[j])<<i>>1;
97          cindex[i*m->nbEBands+j] = -1;
98          /* Find other bands that have the same size */
99          for (k=0;k<=i;k++)
100          {
101             int n;
102             for (n=0;n<m->nbEBands && (k!=i || n<j);n++)
103             {
104                if (N == (eBands[n+1]-eBands[n])<<k>>1)
105                {
106                   cindex[i*m->nbEBands+j] = cindex[k*m->nbEBands+n];
107                   break;
108                }
109             }
110          }
111          if (cache->index[i*m->nbEBands+j] == -1 && N!=0)
112          {
113             int K;
114             entryN[nbEntries] = N;
115             K = 0;
116             while (fits_in32(N,get_pulses(K+1)) && K<MAX_PSEUDO)
117                K++;
118             entryK[nbEntries] = K;
119             cindex[i*m->nbEBands+j] = curr;
120             entryI[nbEntries] = curr;
121
122             curr += K+1;
123             nbEntries++;
124          }
125       }
126    }
127    bits = (unsigned char *)opus_alloc(sizeof(unsigned char)*curr);
128    cache->bits = bits;
129    cache->size = curr;
130    /* Compute the cache for all unique sizes */
131    for (i=0;i<nbEntries;i++)
132    {
133       unsigned char *ptr = bits+entryI[i];
134       opus_int16 tmp[CELT_MAX_PULSES+1];
135       get_required_bits(tmp, entryN[i], get_pulses(entryK[i]), BITRES);
136       for (j=1;j<=entryK[i];j++)
137          ptr[j] = tmp[get_pulses(j)]-1;
138       ptr[0] = entryK[i];
139    }
140
141    /* Compute the maximum rate for each band at which we'll reliably use as
142        many bits as we ask for. */
143    cache->caps = cap = (unsigned char *)opus_alloc(sizeof(cache->caps[0])*(LM+1)*2*m->nbEBands);
144    for (i=0;i<=LM;i++)
145    {
146       for (C=1;C<=2;C++)
147       {
148          for (j=0;j<m->nbEBands;j++)
149          {
150             int N0;
151             int max_bits;
152             N0 = m->eBands[j+1]-m->eBands[j];
153             /* N=1 bands only have a sign bit and fine bits. */
154             if (N0<<i == 1)
155                max_bits = C*(1+MAX_FINE_BITS)<<BITRES;
156             else
157             {
158                const unsigned char *pcache;
159                opus_int32           num;
160                opus_int32           den;
161                int                  LM0;
162                int                  N;
163                int                  offset;
164                int                  ndof;
165                int                  qb;
166                int                  k;
167                LM0 = 0;
168                /* Even-sized bands bigger than N=2 can be split one more time.
169                   As of commit 44203907 all bands >1 are even, including custom modes.*/
170                if (N0 > 2)
171                {
172                   N0>>=1;
173                   LM0--;
174                }
175                /* N0=1 bands can't be split down to N<2. */
176                else if (N0 <= 1)
177                {
178                   LM0=IMIN(i,1);
179                   N0<<=LM0;
180                }
181                /* Compute the cost for the lowest-level PVQ of a fully split
182                    band. */
183                pcache = bits + cindex[(LM0+1)*m->nbEBands+j];
184                max_bits = pcache[pcache[0]]+1;
185                /* Add in the cost of coding regular splits. */
186                N = N0;
187                for(k=0;k<i-LM0;k++){
188                   max_bits <<= 1;
189                   /* Offset the number of qtheta bits by log2(N)/2
190                       + QTHETA_OFFSET compared to their "fair share" of
191                       total/N */
192                   offset = ((m->logN[j]+((LM0+k)<<BITRES))>>1)-QTHETA_OFFSET;
193                   /* The number of qtheta bits we'll allocate if the remainder
194                       is to be max_bits.
195                      The average measured cost for theta is 0.89701 times qb,
196                       approximated here as 459/512. */
197                   num=459*(opus_int32)((2*N-1)*offset+max_bits);
198                   den=((opus_int32)(2*N-1)<<9)-459;
199                   qb = IMIN((num+(den>>1))/den, 57);
200                   celt_assert(qb >= 0);
201                   max_bits += qb;
202                   N <<= 1;
203                }
204                /* Add in the cost of a stereo split, if necessary. */
205                if (C==2)
206                {
207                   max_bits <<= 1;
208                   offset = ((m->logN[j]+(i<<BITRES))>>1)-(N==2?QTHETA_OFFSET_TWOPHASE:QTHETA_OFFSET);
209                   ndof = 2*N-1-(N==2);
210                   /* The average measured cost for theta with the step PDF is
211                       0.95164 times qb, approximated here as 487/512. */
212                   num = (N==2?512:487)*(opus_int32)(max_bits+ndof*offset);
213                   den = ((opus_int32)ndof<<9)-(N==2?512:487);
214                   qb = IMIN((num+(den>>1))/den, (N==2?64:61));
215                   celt_assert(qb >= 0);
216                   max_bits += qb;
217                }
218                /* Add the fine bits we'll use. */
219                /* Compensate for the extra DoF in stereo */
220                ndof = C*N + ((C==2 && N>2) ? 1 : 0);
221                /* Offset the number of fine bits by log2(N)/2 + FINE_OFFSET
222                    compared to their "fair share" of total/N */
223                offset = ((m->logN[j] + (i<<BITRES))>>1)-FINE_OFFSET;
224                /* N=2 is the only point that doesn't match the curve */
225                if (N==2)
226                   offset += 1<<BITRES>>2;
227                /* The number of fine bits we'll allocate if the remainder is
228                    to be max_bits. */
229                num = max_bits+ndof*offset;
230                den = (ndof-1)<<BITRES;
231                qb = IMIN((num+(den>>1))/den, MAX_FINE_BITS);
232                celt_assert(qb >= 0);
233                max_bits += C*qb<<BITRES;
234             }
235             max_bits = (4*max_bits/(C*((m->eBands[j+1]-m->eBands[j])<<i)))-64;
236             celt_assert(max_bits >= 0);
237             celt_assert(max_bits < 256);
238             *cap++ = (unsigned char)max_bits;
239          }
240       }
241    }
242 }
243
244 #endif /* CUSTOM_MODES */
245
246 #define ALLOC_STEPS 6
247
248 static OPUS_INLINE int interp_bits2pulses(const CELTMode *m, int start, int end, int skip_start,
249       const int *bits1, const int *bits2, const int *thresh, const int *cap, opus_int32 total, opus_int32 *_balance,
250       int skip_rsv, int *intensity, int intensity_rsv, int *dual_stereo, int dual_stereo_rsv, int *bits,
251       int *ebits, int *fine_priority, int C, int LM, ec_ctx *ec, int encode, int prev, int signalBandwidth)
252 {
253    opus_int32 psum;
254    int lo, hi;
255    int i, j;
256    int logM;
257    int stereo;
258    int codedBands=-1;
259    int alloc_floor;
260    opus_int32 left, percoeff;
261    int done;
262    opus_int32 balance;
263    SAVE_STACK;
264
265    alloc_floor = C<<BITRES;
266    stereo = C>1;
267
268    logM = LM<<BITRES;
269    lo = 0;
270    hi = 1<<ALLOC_STEPS;
271    for (i=0;i<ALLOC_STEPS;i++)
272    {
273       int mid = (lo+hi)>>1;
274       psum = 0;
275       done = 0;
276       for (j=end;j-->start;)
277       {
278          int tmp = bits1[j] + (mid*(opus_int32)bits2[j]>>ALLOC_STEPS);
279          if (tmp >= thresh[j] || done)
280          {
281             done = 1;
282             /* Don't allocate more than we can actually use */
283             psum += IMIN(tmp, cap[j]);
284          } else {
285             if (tmp >= alloc_floor)
286                psum += alloc_floor;
287          }
288       }
289       if (psum > total)
290          hi = mid;
291       else
292          lo = mid;
293    }
294    psum = 0;
295    /*printf ("interp bisection gave %d\n", lo);*/
296    done = 0;
297    for (j=end;j-->start;)
298    {
299       int tmp = bits1[j] + ((opus_int32)lo*bits2[j]>>ALLOC_STEPS);
300       if (tmp < thresh[j] && !done)
301       {
302          if (tmp >= alloc_floor)
303             tmp = alloc_floor;
304          else
305             tmp = 0;
306       } else
307          done = 1;
308       /* Don't allocate more than we can actually use */
309       tmp = IMIN(tmp, cap[j]);
310       bits[j] = tmp;
311       psum += tmp;
312    }
313
314    /* Decide which bands to skip, working backwards from the end. */
315    for (codedBands=end;;codedBands--)
316    {
317       int band_width;
318       int band_bits;
319       int rem;
320       j = codedBands-1;
321       /* Never skip the first band, nor a band that has been boosted by
322           dynalloc.
323          In the first case, we'd be coding a bit to signal we're going to waste
324           all the other bits.
325          In the second case, we'd be coding a bit to redistribute all the bits
326           we just signaled should be cocentrated in this band. */
327       if (j<=skip_start)
328       {
329          /* Give the bit we reserved to end skipping back. */
330          total += skip_rsv;
331          break;
332       }
333       /*Figure out how many left-over bits we would be adding to this band.
334         This can include bits we've stolen back from higher, skipped bands.*/
335       left = total-psum;
336       percoeff = celt_udiv(left, m->eBands[codedBands]-m->eBands[start]);
337       left -= (m->eBands[codedBands]-m->eBands[start])*percoeff;
338       rem = IMAX(left-(m->eBands[j]-m->eBands[start]),0);
339       band_width = m->eBands[codedBands]-m->eBands[j];
340       band_bits = (int)(bits[j] + percoeff*band_width + rem);
341       /*Only code a skip decision if we're above the threshold for this band.
342         Otherwise it is force-skipped.
343         This ensures that we have enough bits to code the skip flag.*/
344       if (band_bits >= IMAX(thresh[j], alloc_floor+(1<<BITRES)))
345       {
346          if (encode)
347          {
348             /*This if() block is the only part of the allocation function that
349                is not a mandatory part of the bitstream: any bands we choose to
350                skip here must be explicitly signaled.*/
351             int depth_threshold;
352             /*We choose a threshold with some hysteresis to keep bands from
353                fluctuating in and out, but we try not to fold below a certain point. */
354             if (codedBands > 17)
355                depth_threshold = j<prev ? 7 : 9;
356             else
357                depth_threshold = 0;
358 #ifdef FUZZING
359             if ((rand()&0x1) == 0)
360 #else
361             if (codedBands<=start+2 || (band_bits > (depth_threshold*band_width<<LM<<BITRES)>>4 && j<=signalBandwidth))
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 = celt_udiv(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       opus_int32 excess, bit;
441
442       celt_assert(bits[j] >= 0);
443       N0 = m->eBands[j+1]-m->eBands[j];
444       N=N0<<LM;
445       bit = (opus_int32)bits[j]+balance;
446
447       if (N>1)
448       {
449          excess = MAX32(bit-cap[j],0);
450          bits[j] = bit-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))));
474          ebits[j] = celt_udiv(ebits[j], den)>>BITRES;
475
476          /* Make sure not to bust */
477          if (C*ebits[j] > (bits[j]>>BITRES))
478             ebits[j] = bits[j] >> stereo >> BITRES;
479
480          /* More than that is useless because that's about as far as PVQ can go */
481          ebits[j] = IMIN(ebits[j], MAX_FINE_BITS);
482
483          /* If we rounded down or capped this band, make it a candidate for the
484              final fine energy pass */
485          fine_priority[j] = ebits[j]*(den<<BITRES) >= bits[j]+offset;
486
487          /* Remove the allocated fine bits; the rest are assigned to PVQ */
488          bits[j] -= C*ebits[j]<<BITRES;
489
490       } else {
491          /* For N=1, all bits go to fine energy except for a single sign bit */
492          excess = MAX32(0,bit-(C<<BITRES));
493          bits[j] = bit-excess;
494          ebits[j] = 0;
495          fine_priority[j] = 1;
496       }
497
498       /* Fine energy can't take advantage of the re-balancing in
499           quant_all_bands().
500          Instead, do the re-balancing here.*/
501       if(excess > 0)
502       {
503          int extra_fine;
504          int extra_bits;
505          extra_fine = IMIN(excess>>(stereo+BITRES),MAX_FINE_BITS-ebits[j]);
506          ebits[j] += extra_fine;
507          extra_bits = extra_fine*C<<BITRES;
508          fine_priority[j] = extra_bits >= excess-balance;
509          excess -= extra_bits;
510       }
511       balance = excess;
512
513       celt_assert(bits[j] >= 0);
514       celt_assert(ebits[j] >= 0);
515    }
516    /* Save any remaining bits over the cap for the rebalancing in
517        quant_all_bands(). */
518    *_balance = 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       opus_int32 total, opus_int32 *balance, int *pulses, int *ebits, int *fine_priority, int C, int LM, ec_ctx *ec, int encode, int prev, int signalBandwidth)
534 {
535    int lo, hi, len, j;
536    int codedBands;
537    int skip_start;
538    int skip_rsv;
539    int intensity_rsv;
540    int dual_stereo_rsv;
541    VARDECL(int, bits1);
542    VARDECL(int, bits2);
543    VARDECL(int, thresh);
544    VARDECL(int, trim_offset);
545    SAVE_STACK;
546
547    total = IMAX(total, 0);
548    len = m->nbEBands;
549    skip_start = start;
550    /* Reserve a bit to signal the end of manually skipped bands. */
551    skip_rsv = total >= 1<<BITRES ? 1<<BITRES : 0;
552    total -= skip_rsv;
553    /* Reserve bits for the intensity and dual stereo parameters. */
554    intensity_rsv = dual_stereo_rsv = 0;
555    if (C==2)
556    {
557       intensity_rsv = LOG2_FRAC_TABLE[end-start];
558       if (intensity_rsv>total)
559          intensity_rsv = 0;
560       else
561       {
562          total -= intensity_rsv;
563          dual_stereo_rsv = total>=1<<BITRES ? 1<<BITRES : 0;
564          total -= dual_stereo_rsv;
565       }
566    }
567    ALLOC(bits1, len, int);
568    ALLOC(bits2, len, int);
569    ALLOC(thresh, len, int);
570    ALLOC(trim_offset, len, int);
571
572    for (j=start;j<end;j++)
573    {
574       /* Below this threshold, we're sure not to allocate any PVQ bits */
575       thresh[j] = IMAX((C)<<BITRES, (3*(m->eBands[j+1]-m->eBands[j])<<LM<<BITRES)>>4);
576       /* Tilt of the allocation curve */
577       trim_offset[j] = C*(m->eBands[j+1]-m->eBands[j])*(alloc_trim-5-LM)*(end-j-1)
578             *(1<<(LM+BITRES))>>6;
579       /* Giving less resolution to single-coefficient bands because they get
580          more benefit from having one coarse value per coefficient*/
581       if ((m->eBands[j+1]-m->eBands[j])<<LM==1)
582          trim_offset[j] -= C<<BITRES;
583    }
584    lo = 1;
585    hi = m->nbAllocVectors - 1;
586    do
587    {
588       int done = 0;
589       int psum = 0;
590       int mid = (lo+hi) >> 1;
591       for (j=end;j-->start;)
592       {
593          int bitsj;
594          int N = m->eBands[j+1]-m->eBands[j];
595          bitsj = C*N*m->allocVectors[mid*len+j]<<LM>>2;
596          if (bitsj > 0)
597             bitsj = IMAX(0, bitsj + trim_offset[j]);
598          bitsj += offsets[j];
599          if (bitsj >= thresh[j] || done)
600          {
601             done = 1;
602             /* Don't allocate more than we can actually use */
603             psum += IMIN(bitsj, cap[j]);
604          } else {
605             if (bitsj >= 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 bits1j, bits2j;
621       int N = m->eBands[j+1]-m->eBands[j];
622       bits1j = C*N*m->allocVectors[lo*len+j]<<LM>>2;
623       bits2j = hi>=m->nbAllocVectors ?
624             cap[j] : C*N*m->allocVectors[hi*len+j]<<LM>>2;
625       if (bits1j > 0)
626          bits1j = IMAX(0, bits1j + trim_offset[j]);
627       if (bits2j > 0)
628          bits2j = IMAX(0, bits2j + trim_offset[j]);
629       if (lo > 0)
630          bits1j += offsets[j];
631       bits2j += offsets[j];
632       if (offsets[j]>0)
633          skip_start = j;
634       bits2j = IMAX(0,bits2j-bits1j);
635       bits1[j] = bits1j;
636       bits2[j] = bits2j;
637    }
638    codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap,
639          total, balance, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv,
640          pulses, ebits, fine_priority, C, LM, ec, encode, prev, signalBandwidth);
641    RESTORE_STACK;
642    return codedBands;
643 }
644