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.*/
fits_in32(int _n,int _k)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
compute_pulse_cache(CELTMode * m,int LM)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
interp_bits2pulses(const CELTMode * m,int start,int end,int skip_start,const int * bits1,const int * bits2,const int * thresh,const int * cap,opus_int32 total,opus_int32 * _balance,int skip_rsv,int * intensity,int intensity_rsv,int * dual_stereo,int dual_stereo_rsv,int * bits,int * ebits,int * fine_priority,int C,int LM,ec_ctx * ec,int encode,int prev,int signalBandwidth)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 /*Choose a threshold with some hysteresis to keep bands from
352 fluctuating in and out.*/
353 #ifdef FUZZING
354 if ((rand()&0x1) == 0)
355 #else
356 if (codedBands<=start+2 || (band_bits > ((j<prev?7:9)*band_width<<LM<<BITRES)>>4 && j<=signalBandwidth))
357 #endif
358 {
359 ec_enc_bit_logp(ec, 1, 1);
360 break;
361 }
362 ec_enc_bit_logp(ec, 0, 1);
363 } else if (ec_dec_bit_logp(ec, 1)) {
364 break;
365 }
366 /*We used a bit to skip this band.*/
367 psum += 1<<BITRES;
368 band_bits -= 1<<BITRES;
369 }
370 /*Reclaim the bits originally allocated to this band.*/
371 psum -= bits[j]+intensity_rsv;
372 if (intensity_rsv > 0)
373 intensity_rsv = LOG2_FRAC_TABLE[j-start];
374 psum += intensity_rsv;
375 if (band_bits >= alloc_floor)
376 {
377 /*If we have enough for a fine energy bit per channel, use it.*/
378 psum += alloc_floor;
379 bits[j] = alloc_floor;
380 } else {
381 /*Otherwise this band gets nothing at all.*/
382 bits[j] = 0;
383 }
384 }
385
386 celt_assert(codedBands > start);
387 /* Code the intensity and dual stereo parameters. */
388 if (intensity_rsv > 0)
389 {
390 if (encode)
391 {
392 *intensity = IMIN(*intensity, codedBands);
393 ec_enc_uint(ec, *intensity-start, codedBands+1-start);
394 }
395 else
396 *intensity = start+ec_dec_uint(ec, codedBands+1-start);
397 }
398 else
399 *intensity = 0;
400 if (*intensity <= start)
401 {
402 total += dual_stereo_rsv;
403 dual_stereo_rsv = 0;
404 }
405 if (dual_stereo_rsv > 0)
406 {
407 if (encode)
408 ec_enc_bit_logp(ec, *dual_stereo, 1);
409 else
410 *dual_stereo = ec_dec_bit_logp(ec, 1);
411 }
412 else
413 *dual_stereo = 0;
414
415 /* Allocate the remaining bits */
416 left = total-psum;
417 percoeff = celt_udiv(left, m->eBands[codedBands]-m->eBands[start]);
418 left -= (m->eBands[codedBands]-m->eBands[start])*percoeff;
419 for (j=start;j<codedBands;j++)
420 bits[j] += ((int)percoeff*(m->eBands[j+1]-m->eBands[j]));
421 for (j=start;j<codedBands;j++)
422 {
423 int tmp = (int)IMIN(left, m->eBands[j+1]-m->eBands[j]);
424 bits[j] += tmp;
425 left -= tmp;
426 }
427 /*for (j=0;j<end;j++)printf("%d ", bits[j]);printf("\n");*/
428
429 balance = 0;
430 for (j=start;j<codedBands;j++)
431 {
432 int N0, N, den;
433 int offset;
434 int NClogN;
435 opus_int32 excess, bit;
436
437 celt_assert(bits[j] >= 0);
438 N0 = m->eBands[j+1]-m->eBands[j];
439 N=N0<<LM;
440 bit = (opus_int32)bits[j]+balance;
441
442 if (N>1)
443 {
444 excess = MAX32(bit-cap[j],0);
445 bits[j] = bit-excess;
446
447 /* Compensate for the extra DoF in stereo */
448 den=(C*N+ ((C==2 && N>2 && !*dual_stereo && j<*intensity) ? 1 : 0));
449
450 NClogN = den*(m->logN[j] + logM);
451
452 /* Offset for the number of fine bits by log2(N)/2 + FINE_OFFSET
453 compared to their "fair share" of total/N */
454 offset = (NClogN>>1)-den*FINE_OFFSET;
455
456 /* N=2 is the only point that doesn't match the curve */
457 if (N==2)
458 offset += den<<BITRES>>2;
459
460 /* Changing the offset for allocating the second and third
461 fine energy bit */
462 if (bits[j] + offset < den*2<<BITRES)
463 offset += NClogN>>2;
464 else if (bits[j] + offset < den*3<<BITRES)
465 offset += NClogN>>3;
466
467 /* Divide with rounding */
468 ebits[j] = IMAX(0, (bits[j] + offset + (den<<(BITRES-1))));
469 ebits[j] = celt_udiv(ebits[j], den)>>BITRES;
470
471 /* Make sure not to bust */
472 if (C*ebits[j] > (bits[j]>>BITRES))
473 ebits[j] = bits[j] >> stereo >> BITRES;
474
475 /* More than that is useless because that's about as far as PVQ can go */
476 ebits[j] = IMIN(ebits[j], MAX_FINE_BITS);
477
478 /* If we rounded down or capped this band, make it a candidate for the
479 final fine energy pass */
480 fine_priority[j] = ebits[j]*(den<<BITRES) >= bits[j]+offset;
481
482 /* Remove the allocated fine bits; the rest are assigned to PVQ */
483 bits[j] -= C*ebits[j]<<BITRES;
484
485 } else {
486 /* For N=1, all bits go to fine energy except for a single sign bit */
487 excess = MAX32(0,bit-(C<<BITRES));
488 bits[j] = bit-excess;
489 ebits[j] = 0;
490 fine_priority[j] = 1;
491 }
492
493 /* Fine energy can't take advantage of the re-balancing in
494 quant_all_bands().
495 Instead, do the re-balancing here.*/
496 if(excess > 0)
497 {
498 int extra_fine;
499 int extra_bits;
500 extra_fine = IMIN(excess>>(stereo+BITRES),MAX_FINE_BITS-ebits[j]);
501 ebits[j] += extra_fine;
502 extra_bits = extra_fine*C<<BITRES;
503 fine_priority[j] = extra_bits >= excess-balance;
504 excess -= extra_bits;
505 }
506 balance = excess;
507
508 celt_assert(bits[j] >= 0);
509 celt_assert(ebits[j] >= 0);
510 }
511 /* Save any remaining bits over the cap for the rebalancing in
512 quant_all_bands(). */
513 *_balance = balance;
514
515 /* The skipped bands use all their bits for fine energy. */
516 for (;j<end;j++)
517 {
518 ebits[j] = bits[j] >> stereo >> BITRES;
519 celt_assert(C*ebits[j]<<BITRES == bits[j]);
520 bits[j] = 0;
521 fine_priority[j] = ebits[j]<1;
522 }
523 RESTORE_STACK;
524 return codedBands;
525 }
526
compute_allocation(const CELTMode * m,int start,int end,const int * offsets,const int * cap,int alloc_trim,int * intensity,int * dual_stereo,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)527 int compute_allocation(const CELTMode *m, int start, int end, const int *offsets, const int *cap, int alloc_trim, int *intensity, int *dual_stereo,
528 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)
529 {
530 int lo, hi, len, j;
531 int codedBands;
532 int skip_start;
533 int skip_rsv;
534 int intensity_rsv;
535 int dual_stereo_rsv;
536 VARDECL(int, bits1);
537 VARDECL(int, bits2);
538 VARDECL(int, thresh);
539 VARDECL(int, trim_offset);
540 SAVE_STACK;
541
542 total = IMAX(total, 0);
543 len = m->nbEBands;
544 skip_start = start;
545 /* Reserve a bit to signal the end of manually skipped bands. */
546 skip_rsv = total >= 1<<BITRES ? 1<<BITRES : 0;
547 total -= skip_rsv;
548 /* Reserve bits for the intensity and dual stereo parameters. */
549 intensity_rsv = dual_stereo_rsv = 0;
550 if (C==2)
551 {
552 intensity_rsv = LOG2_FRAC_TABLE[end-start];
553 if (intensity_rsv>total)
554 intensity_rsv = 0;
555 else
556 {
557 total -= intensity_rsv;
558 dual_stereo_rsv = total>=1<<BITRES ? 1<<BITRES : 0;
559 total -= dual_stereo_rsv;
560 }
561 }
562 ALLOC(bits1, len, int);
563 ALLOC(bits2, len, int);
564 ALLOC(thresh, len, int);
565 ALLOC(trim_offset, len, int);
566
567 for (j=start;j<end;j++)
568 {
569 /* Below this threshold, we're sure not to allocate any PVQ bits */
570 thresh[j] = IMAX((C)<<BITRES, (3*(m->eBands[j+1]-m->eBands[j])<<LM<<BITRES)>>4);
571 /* Tilt of the allocation curve */
572 trim_offset[j] = C*(m->eBands[j+1]-m->eBands[j])*(alloc_trim-5-LM)*(end-j-1)
573 *(1<<(LM+BITRES))>>6;
574 /* Giving less resolution to single-coefficient bands because they get
575 more benefit from having one coarse value per coefficient*/
576 if ((m->eBands[j+1]-m->eBands[j])<<LM==1)
577 trim_offset[j] -= C<<BITRES;
578 }
579 lo = 1;
580 hi = m->nbAllocVectors - 1;
581 do
582 {
583 int done = 0;
584 int psum = 0;
585 int mid = (lo+hi) >> 1;
586 for (j=end;j-->start;)
587 {
588 int bitsj;
589 int N = m->eBands[j+1]-m->eBands[j];
590 bitsj = C*N*m->allocVectors[mid*len+j]<<LM>>2;
591 if (bitsj > 0)
592 bitsj = IMAX(0, bitsj + trim_offset[j]);
593 bitsj += offsets[j];
594 if (bitsj >= thresh[j] || done)
595 {
596 done = 1;
597 /* Don't allocate more than we can actually use */
598 psum += IMIN(bitsj, cap[j]);
599 } else {
600 if (bitsj >= C<<BITRES)
601 psum += C<<BITRES;
602 }
603 }
604 if (psum > total)
605 hi = mid - 1;
606 else
607 lo = mid + 1;
608 /*printf ("lo = %d, hi = %d\n", lo, hi);*/
609 }
610 while (lo <= hi);
611 hi = lo--;
612 /*printf ("interp between %d and %d\n", lo, hi);*/
613 for (j=start;j<end;j++)
614 {
615 int bits1j, bits2j;
616 int N = m->eBands[j+1]-m->eBands[j];
617 bits1j = C*N*m->allocVectors[lo*len+j]<<LM>>2;
618 bits2j = hi>=m->nbAllocVectors ?
619 cap[j] : C*N*m->allocVectors[hi*len+j]<<LM>>2;
620 if (bits1j > 0)
621 bits1j = IMAX(0, bits1j + trim_offset[j]);
622 if (bits2j > 0)
623 bits2j = IMAX(0, bits2j + trim_offset[j]);
624 if (lo > 0)
625 bits1j += offsets[j];
626 bits2j += offsets[j];
627 if (offsets[j]>0)
628 skip_start = j;
629 bits2j = IMAX(0,bits2j-bits1j);
630 bits1[j] = bits1j;
631 bits2[j] = bits2j;
632 }
633 codedBands = interp_bits2pulses(m, start, end, skip_start, bits1, bits2, thresh, cap,
634 total, balance, skip_rsv, intensity, intensity_rsv, dual_stereo, dual_stereo_rsv,
635 pulses, ebits, fine_priority, C, LM, ec, encode, prev, signalBandwidth);
636 RESTORE_STACK;
637 return codedBands;
638 }
639
640