eden-emu/opus
19
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Making the band definition the same at all frame sizes.

Browse source
This commit is contained in:
Jean-Marc Valin 2010-04-26 07:08:44 -04:00
parent be8d1259af
commit 65ee67ac55
8 changed files with 113 additions and 112 deletions
Download patch file Download diff file Expand all files Collapse all files

106
libcelt/bands.c
View file

@ -48,7 +48,7 @@
#ifdef FIXED_POINT #ifdef FIXED_POINT
/* Compute the amplitude (sqrt energy) in each of the bands */ /* Compute the amplitude (sqrt energy) in each of the bands */
void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bank, int _C) void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bank, int _C, int M)
{ {
int i, c, N; int i, c, N;
const celt_int16 *eBands = m->eBands; const celt_int16 *eBands = m->eBands;
@ -62,18 +62,18 @@ void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bank
celt_word32 maxval=0; celt_word32 maxval=0;
celt_word32 sum = 0; celt_word32 sum = 0;
j=eBands[i]; do { j=M*eBands[i]; do {
maxval = MAX32(maxval, X[j+c*N]); maxval = MAX32(maxval, X[j+c*N]);
maxval = MAX32(maxval, -X[j+c*N]); maxval = MAX32(maxval, -X[j+c*N]);
} while (++j<eBands[i+1]); } while (++j<M*eBands[i+1]);
if (maxval > 0) if (maxval > 0)
{ {
int shift = celt_ilog2(maxval)-10; int shift = celt_ilog2(maxval)-10;
j=eBands[i]; do { j=M*eBands[i]; do {
sum = MAC16_16(sum, EXTRACT16(VSHR32(X[j+c*N],shift)), sum = MAC16_16(sum, EXTRACT16(VSHR32(X[j+c*N],shift)),
EXTRACT16(VSHR32(X[j+c*N],shift))); EXTRACT16(VSHR32(X[j+c*N],shift)));
} while (++j<eBands[i+1]); } while (++j<M*eBands[i+1]);
/* We're adding one here to make damn sure we never end up with a pitch vector that's /* We're adding one here to make damn sure we never end up with a pitch vector that's
larger than unity norm */ larger than unity norm */
bank[i+c*m->nbEBands] = EPSILON+VSHR32(EXTEND32(celt_sqrt(sum)),-shift); bank[i+c*m->nbEBands] = EPSILON+VSHR32(EXTEND32(celt_sqrt(sum)),-shift);
@ -87,7 +87,7 @@ void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bank
} }
/* Normalise each band such that the energy is one. */ /* Normalise each band such that the energy is one. */
void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_norm * restrict X, const celt_ener *bank, int _C) void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_norm * restrict X, const celt_ener *bank, int _C, int M)
{ {
int i, c, N; int i, c, N;
const celt_int16 *eBands = m->eBands; const celt_int16 *eBands = m->eBands;
@ -102,16 +102,16 @@ void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_nor
shift = celt_zlog2(bank[i+c*m->nbEBands])-13; shift = celt_zlog2(bank[i+c*m->nbEBands])-13;
E = VSHR32(bank[i+c*m->nbEBands], shift); E = VSHR32(bank[i+c*m->nbEBands], shift);
g = EXTRACT16(celt_rcp(SHL32(E,3))); g = EXTRACT16(celt_rcp(SHL32(E,3)));
j=eBands[i]; do { j=M*eBands[i]; do {
X[j+c*N] = MULT16_16_Q15(VSHR32(freq[j+c*N],shift-1),g); X[j+c*N] = MULT16_16_Q15(VSHR32(freq[j+c*N],shift-1),g);
} while (++j<eBands[i+1]); } while (++j<M*eBands[i+1]);
} while (++i<m->nbEBands); } while (++i<m->nbEBands);
} }
} }
#else /* FIXED_POINT */ #else /* FIXED_POINT */
/* Compute the amplitude (sqrt energy) in each of the bands */ /* Compute the amplitude (sqrt energy) in each of the bands */
void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bank, int _C) void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bank, int _C, int M)
{ {
int i, c, N; int i, c, N;
const celt_int16 *eBands = m->eBands; const celt_int16 *eBands = m->eBands;
@ -123,7 +123,7 @@ void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bank
{ {
int j; int j;
celt_word32 sum = 1e-10; celt_word32 sum = 1e-10;
for (j=eBands[i];j<eBands[i+1];j++) for (j=M*eBands[i];j<M*eBands[i+1];j++)
sum += X[j+c*N]*X[j+c*N]; sum += X[j+c*N]*X[j+c*N];
bank[i+c*m->nbEBands] = sqrt(sum); bank[i+c*m->nbEBands] = sqrt(sum);
/*printf ("%f ", bank[i+c*m->nbEBands]);*/ /*printf ("%f ", bank[i+c*m->nbEBands]);*/
@ -133,7 +133,7 @@ void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bank
} }
#ifdef EXP_PSY #ifdef EXP_PSY
void compute_noise_energies(const CELTMode *m, const celt_sig *X, const celt_word16 *tonality, celt_ener *bank, int _C) void compute_noise_energies(const CELTMode *m, const celt_sig *X, const celt_word16 *tonality, celt_ener *bank, int _C, int M)
{ {
int i, c, N; int i, c, N;
const celt_int16 *eBands = m->eBands; const celt_int16 *eBands = m->eBands;
@ -145,7 +145,7 @@ void compute_noise_energies(const CELTMode *m, const celt_sig *X, const celt_wor
{ {
int j; int j;
celt_word32 sum = 1e-10; celt_word32 sum = 1e-10;
for (j=eBands[i];j<eBands[i+1];j++) for (j=M*eBands[i];j<M*eBands[i+1];j++)
sum += X[j*C+c]*X[j+c*N]*tonality[j]; sum += X[j*C+c]*X[j+c*N]*tonality[j];
bank[i+c*m->nbEBands] = sqrt(sum); bank[i+c*m->nbEBands] = sqrt(sum);
/*printf ("%f ", bank[i+c*m->nbEBands]);*/ /*printf ("%f ", bank[i+c*m->nbEBands]);*/
@ -156,7 +156,7 @@ void compute_noise_energies(const CELTMode *m, const celt_sig *X, const celt_wor
#endif #endif
/* Normalise each band such that the energy is one. */ /* Normalise each band such that the energy is one. */
void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_norm * restrict X, const celt_ener *bank, int _C) void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_norm * restrict X, const celt_ener *bank, int _C, int M)
{ {
int i, c, N; int i, c, N;
const celt_int16 *eBands = m->eBands; const celt_int16 *eBands = m->eBands;
@ -168,7 +168,7 @@ void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_nor
{ {
int j; int j;
celt_word16 g = 1.f/(1e-10f+bank[i+c*m->nbEBands]); celt_word16 g = 1.f/(1e-10f+bank[i+c*m->nbEBands]);
for (j=eBands[i];j<eBands[i+1];j++) for (j=M*eBands[i];j<M*eBands[i+1];j++)
X[j+c*N] = freq[j+c*N]*g; X[j+c*N] = freq[j+c*N]*g;
} }
} }
@ -176,7 +176,7 @@ void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_nor
#endif /* FIXED_POINT */ #endif /* FIXED_POINT */
void renormalise_bands(const CELTMode *m, celt_norm * restrict X, int _C) void renormalise_bands(const CELTMode *m, celt_norm * restrict X, int _C, int M)
{ {
int i, c; int i, c;
const celt_int16 *eBands = m->eBands; const celt_int16 *eBands = m->eBands;
@ -184,13 +184,13 @@ void renormalise_bands(const CELTMode *m, celt_norm * restrict X, int _C)
for (c=0;c<C;c++) for (c=0;c<C;c++)
{ {
i=0; do { i=0; do {
renormalise_vector(X+eBands[i]+c*m->eBands[m->nbEBands+1], Q15ONE, eBands[i+1]-eBands[i], 1); renormalise_vector(X+M*eBands[i]+c*M*eBands[m->nbEBands+1], Q15ONE, M*eBands[i+1]-M*eBands[i], 1);
} while (++i<m->nbEBands); } while (++i<m->nbEBands);
} }
} }
/* De-normalise the energy to produce the synthesis from the unit-energy bands */ /* De-normalise the energy to produce the synthesis from the unit-energy bands */
void denormalise_bands(const CELTMode *m, const celt_norm * restrict X, celt_sig * restrict freq, const celt_ener *bank, int _C) void denormalise_bands(const CELTMode *m, const celt_norm * restrict X, celt_sig * restrict freq, const celt_ener *bank, int _C, int M)
{ {
int i, c, N; int i, c, N;
const celt_int16 *eBands = m->eBands; const celt_int16 *eBands = m->eBands;
@ -208,14 +208,14 @@ void denormalise_bands(const CELTMode *m, const celt_norm * restrict X, celt_sig
{ {
int j, end; int j, end;
celt_word32 g = SHR32(bank[i+c*m->nbEBands],1); celt_word32 g = SHR32(bank[i+c*m->nbEBands],1);
j=eBands[i]; j=M*eBands[i];
end = eBands[i+1]; end = M*eBands[i+1];
do { do {
*f++ = SHL32(MULT16_32_Q15(*x, g),2); *f++ = SHL32(MULT16_32_Q15(*x, g),2);
x++; x++;
} while (++j<end); } while (++j<end);
} }
for (i=eBands[m->nbEBands];i<eBands[m->nbEBands+1];i++) for (i=M*eBands[m->nbEBands];i<M*eBands[m->nbEBands+1];i++)
*f++ = 0; *f++ = 0;
} }
} }
@ -341,7 +341,7 @@ void apply_pitch(const CELTMode *m, celt_sig *X, const celt_sig *P, int gain_id,
#ifndef DISABLE_STEREO #ifndef DISABLE_STEREO
static void stereo_band_mix(const CELTMode *m, celt_norm *X, celt_norm *Y, const celt_ener *bank, int stereo_mode, int bandID, int dir) static void stereo_band_mix(const CELTMode *m, celt_norm *X, celt_norm *Y, const celt_ener *bank, int stereo_mode, int bandID, int dir, int M)
{ {
int i = bandID; int i = bandID;
const celt_int16 *eBands = m->eBands; const celt_int16 *eBands = m->eBands;
@ -364,7 +364,7 @@ static void stereo_band_mix(const CELTMode *m, celt_norm *X, celt_norm *Y, const
a1 = DIV32_16(SHL32(EXTEND32(left),14),norm); a1 = DIV32_16(SHL32(EXTEND32(left),14),norm);
a2 = dir*DIV32_16(SHL32(EXTEND32(right),14),norm); a2 = dir*DIV32_16(SHL32(EXTEND32(right),14),norm);
} }
for (j=0;j<eBands[i+1]-eBands[i];j++) for (j=0;j<M*eBands[i+1]-M*eBands[i];j++)
{ {
celt_norm r, l; celt_norm r, l;
l = X[j]; l = X[j];
@ -377,7 +377,7 @@ static void stereo_band_mix(const CELTMode *m, celt_norm *X, celt_norm *Y, const
#endif /* DISABLE_STEREO */ #endif /* DISABLE_STEREO */
int folding_decision(const CELTMode *m, celt_norm *X, celt_word16 *average, int *last_decision, int _C) int folding_decision(const CELTMode *m, celt_norm *X, celt_word16 *average, int *last_decision, int _C, int M)
{ {
int i, c, N0; int i, c, N0;
int NR=0; int NR=0;
@ -395,8 +395,8 @@ int folding_decision(const CELTMode *m, celt_norm *X, celt_word16 *average, int
int max_i=0; int max_i=0;
celt_word16 max_val=EPSILON; celt_word16 max_val=EPSILON;
celt_word32 floor_ener=EPSILON; celt_word32 floor_ener=EPSILON;
celt_norm * restrict x = X+eBands[i]+c*N0; celt_norm * restrict x = X+M*eBands[i]+c*N0;
N = eBands[i+1]-eBands[i]; N = M*eBands[i+1]-M*eBands[i];
for (j=0;j<N;j++) for (j=0;j<N;j++)
{ {
if (ABS16(x[j])>max_val) if (ABS16(x[j])>max_val)
@ -448,7 +448,7 @@ int folding_decision(const CELTMode *m, celt_norm *X, celt_word16 *average, int
} }
/* Quantisation of the residual */ /* Quantisation of the residual */
void quant_bands(const CELTMode *m, int start, celt_norm * restrict X, const celt_ener *bandE, int *pulses, int shortBlocks, int fold, int resynth, int total_bits, int encode, void *enc_dec) void quant_bands(const CELTMode *m, int start, celt_norm * restrict X, const celt_ener *bandE, int *pulses, int shortBlocks, int fold, int resynth, int total_bits, int encode, void *enc_dec, int M)
{ {
int i, j, remaining_bits, balance; int i, j, remaining_bits, balance;
const celt_int16 * restrict eBands = m->eBands; const celt_int16 * restrict eBands = m->eBands;
@ -458,7 +458,7 @@ void quant_bands(const CELTMode *m, int start, celt_norm * restrict X, const cel
SAVE_STACK; SAVE_STACK;
B = shortBlocks ? m->nbShortMdcts : 1; B = shortBlocks ? m->nbShortMdcts : 1;
ALLOC(_norm, eBands[m->nbEBands+1], celt_norm); ALLOC(_norm, M*eBands[m->nbEBands+1], celt_norm);
norm = _norm; norm = _norm;
balance = 0; balance = 0;
@ -471,7 +471,7 @@ void quant_bands(const CELTMode *m, int start, celt_norm * restrict X, const cel
int curr_balance, curr_bits; int curr_balance, curr_bits;
N = eBands[i+1]-eBands[i]; N = M*eBands[i+1]-M*eBands[i];
BPbits = m->bits; BPbits = m->bits;
if (encode) if (encode)
@ -502,18 +502,18 @@ void quant_bands(const CELTMode *m, int start, celt_norm * restrict X, const cel
{ {
int spread = fold ? B : 0; int spread = fold ? B : 0;
if (encode) if (encode)
alg_quant(X+eBands[i], eBands[i+1]-eBands[i], q, spread, resynth, enc_dec); alg_quant(X+M*eBands[i], N, q, spread, resynth, enc_dec);
else else
alg_unquant(X+eBands[i], eBands[i+1]-eBands[i], q, spread, enc_dec); alg_unquant(X+M*eBands[i], N, q, spread, enc_dec);
} else { } else {
if (resynth) if (resynth)
intra_fold(m, start, eBands[i+1]-eBands[i], norm, X+eBands[i], eBands[i], B); intra_fold(m, start, N, norm, X+M*eBands[i], M*eBands[i], B, M);
} }
if (resynth) if (resynth)
{ {
celt_word16 n; celt_word16 n;
n = celt_sqrt(SHL32(EXTEND32(eBands[i+1]-eBands[i]),22)); n = celt_sqrt(SHL32(EXTEND32(N),22));
for (j=eBands[i];j<eBands[i+1];j++) for (j=M*eBands[i];j<M*eBands[i+1];j++)
norm[j] = MULT16_16_Q15(n,X[j]); norm[j] = MULT16_16_Q15(n,X[j]);
} }
} }
@ -522,7 +522,7 @@ void quant_bands(const CELTMode *m, int start, celt_norm * restrict X, const cel
#ifndef DISABLE_STEREO #ifndef DISABLE_STEREO
void quant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_ener *bandE, int *pulses, int shortBlocks, int fold, int resynth, int total_bits, ec_enc *enc) void quant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_ener *bandE, int *pulses, int shortBlocks, int fold, int resynth, int total_bits, ec_enc *enc, int M)
{ {
int i, j, remaining_bits, balance; int i, j, remaining_bits, balance;
const celt_int16 * restrict eBands = m->eBands; const celt_int16 * restrict eBands = m->eBands;
@ -533,7 +533,7 @@ void quant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_
SAVE_STACK; SAVE_STACK;
B = shortBlocks ? m->nbShortMdcts : 1; B = shortBlocks ? m->nbShortMdcts : 1;
ALLOC(_norm, eBands[m->nbEBands+1], celt_norm); ALLOC(_norm, M*eBands[m->nbEBands+1], celt_norm);
norm = _norm; norm = _norm;
balance = 0; balance = 0;
@ -550,11 +550,11 @@ void quant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_
int qalloc; int qalloc;
celt_norm * restrict X, * restrict Y; celt_norm * restrict X, * restrict Y;
X = _X+eBands[i]; X = _X+M*eBands[i];
Y = X+eBands[m->nbEBands+1]; Y = X+M*eBands[m->nbEBands+1];
BPbits = m->bits; BPbits = m->bits;
N = eBands[i+1]-eBands[i]; N = M*eBands[i+1]-M*eBands[i];
tell = ec_enc_tell(enc, BITRES); tell = ec_enc_tell(enc, BITRES);
if (i != start) if (i != start)
balance -= tell; balance -= tell;
@ -575,7 +575,7 @@ void quant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_
if (qb>14) if (qb>14)
qb = 14; qb = 14;
stereo_band_mix(m, X, Y, bandE, qb==0, i, 1); stereo_band_mix(m, X, Y, bandE, qb==0, i, 1, M);
mid = renormalise_vector(X, Q15ONE, N, 1); mid = renormalise_vector(X, Q15ONE, N, 1);
side = renormalise_vector(Y, Q15ONE, N, 1); side = renormalise_vector(Y, Q15ONE, N, 1);
@ -715,7 +715,7 @@ void quant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_
alg_quant(X, N, q1, spread, resynth, enc); alg_quant(X, N, q1, spread, resynth, enc);
} else { } else {
if (resynth) if (resynth)
intra_fold(m, start, eBands[i+1]-eBands[i], norm, X, eBands[i], B); intra_fold(m, start, N, norm, X, M*eBands[i], B, M);
} }
if (q2 > 0) { if (q2 > 0) {
int spread = fold ? B : 0; int spread = fold ? B : 0;
@ -737,16 +737,16 @@ void quant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_
mid = (1.f/32768)*imid; mid = (1.f/32768)*imid;
side = (1.f/32768)*iside; side = (1.f/32768)*iside;
#endif #endif
n = celt_sqrt(SHL32(EXTEND32(eBands[i+1]-eBands[i]),22)); n = celt_sqrt(SHL32(EXTEND32(N),22));
for (j=0;j<N;j++) for (j=0;j<N;j++)
norm[eBands[i]+j] = MULT16_16_Q15(n,X[j]); norm[M*eBands[i]+j] = MULT16_16_Q15(n,X[j]);
for (j=0;j<N;j++) for (j=0;j<N;j++)
X[j] = MULT16_16_Q15(X[j], mid); X[j] = MULT16_16_Q15(X[j], mid);
for (j=0;j<N;j++) for (j=0;j<N;j++)
Y[j] = MULT16_16_Q15(Y[j], side); Y[j] = MULT16_16_Q15(Y[j], side);
stereo_band_mix(m, X, Y, bandE, 0, i, -1); stereo_band_mix(m, X, Y, bandE, 0, i, -1, M);
renormalise_vector(X, Q15ONE, N, 1); renormalise_vector(X, Q15ONE, N, 1);
renormalise_vector(Y, Q15ONE, N, 1); renormalise_vector(Y, Q15ONE, N, 1);
} }
@ -758,7 +758,7 @@ void quant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_
#ifndef DISABLE_STEREO #ifndef DISABLE_STEREO
void unquant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_ener *bandE, int *pulses, int shortBlocks, int fold, int total_bits, ec_dec *dec) void unquant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const celt_ener *bandE, int *pulses, int shortBlocks, int fold, int total_bits, ec_dec *dec, int M)
{ {
int i, j, remaining_bits, balance; int i, j, remaining_bits, balance;
const celt_int16 * restrict eBands = m->eBands; const celt_int16 * restrict eBands = m->eBands;
@ -769,7 +769,7 @@ void unquant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const cel
SAVE_STACK; SAVE_STACK;
B = shortBlocks ? m->nbShortMdcts : 1; B = shortBlocks ? m->nbShortMdcts : 1;
ALLOC(_norm, eBands[m->nbEBands+1], celt_norm); ALLOC(_norm, M*eBands[m->nbEBands+1], celt_norm);
norm = _norm; norm = _norm;
balance = 0; balance = 0;
@ -787,11 +787,11 @@ void unquant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const cel
int qalloc; int qalloc;
celt_norm * restrict X, * restrict Y; celt_norm * restrict X, * restrict Y;
X = _X+eBands[i]; X = _X+M*eBands[i];
Y = X+eBands[m->nbEBands+1]; Y = X+M*eBands[m->nbEBands+1];
BPbits = m->bits; BPbits = m->bits;
N = eBands[i+1]-eBands[i]; N = M*eBands[i+1]-M*eBands[i];
tell = ec_dec_tell(dec, BITRES); tell = ec_dec_tell(dec, BITRES);
if (i != start) if (i != start)
balance -= tell; balance -= tell;
@ -836,7 +836,7 @@ void unquant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const cel
iside = bitexact_cos(16384-itheta); iside = bitexact_cos(16384-itheta);
delta = (N-1)*(log2_frac(iside,BITRES+2)-log2_frac(imid,BITRES+2))>>2; delta = (N-1)*(log2_frac(iside,BITRES+2)-log2_frac(imid,BITRES+2))>>2;
} }
n = celt_sqrt(SHL32(EXTEND32(eBands[i+1]-eBands[i]),22)); n = celt_sqrt(SHL32(EXTEND32(N),22));
#if 1 #if 1
if (N==2) if (N==2)
@ -928,7 +928,7 @@ void unquant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const cel
int spread = fold ? B : 0; int spread = fold ? B : 0;
alg_unquant(X, N, q1, spread, dec); alg_unquant(X, N, q1, spread, dec);
} else } else
intra_fold(m, start, eBands[i+1]-eBands[i], norm, X, eBands[i], B); intra_fold(m, start, N, norm, X, M*eBands[i], B, M);
if (q2 > 0) if (q2 > 0)
{ {
int spread = fold ? B : 0; int spread = fold ? B : 0;
@ -936,7 +936,7 @@ void unquant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const cel
} else } else
for (j=0;j<N;j++) for (j=0;j<N;j++)
Y[j] = 0; Y[j] = 0;
/*orthogonalize(X+C*eBands[i], X+C*eBands[i]+N, N);*/ /*orthogonalize(X+C*M*eBands[i], X+C*M*eBands[i]+N, N);*/
} }
balance += pulses[i] + tell; balance += pulses[i] + tell;
@ -948,14 +948,14 @@ void unquant_bands_stereo(const CELTMode *m, int start, celt_norm *_X, const cel
side = (1.f/32768)*iside; side = (1.f/32768)*iside;
#endif #endif
for (j=0;j<N;j++) for (j=0;j<N;j++)
norm[eBands[i]+j] = MULT16_16_Q15(n,X[j]); norm[M*eBands[i]+j] = MULT16_16_Q15(n,X[j]);
for (j=0;j<N;j++) for (j=0;j<N;j++)
X[j] = MULT16_16_Q15(X[j], mid); X[j] = MULT16_16_Q15(X[j], mid);
for (j=0;j<N;j++) for (j=0;j<N;j++)
Y[j] = MULT16_16_Q15(Y[j], side); Y[j] = MULT16_16_Q15(Y[j], side);
stereo_band_mix(m, X, Y, bandE, 0, i, -1); stereo_band_mix(m, X, Y, bandE, 0, i, -1, M);
renormalise_vector(X, Q15ONE, N, 1); renormalise_vector(X, Q15ONE, N, 1);
renormalise_vector(Y, Q15ONE, N, 1); renormalise_vector(Y, Q15ONE, N, 1);
} }

18
libcelt/bands.h
View file

@ -45,7 +45,7 @@
* @param X Spectrum * @param X Spectrum
* @param bands Square root of the energy for each band (returned) * @param bands Square root of the energy for each band (returned)
*/ */
void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bands, int _C); void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *bands, int _C, int M);
/*void compute_noise_energies(const CELTMode *m, const celt_sig *X, const celt_word16 *tonality, celt_ener *bank);*/ /*void compute_noise_energies(const CELTMode *m, const celt_sig *X, const celt_word16 *tonality, celt_ener *bank);*/
@ -55,16 +55,16 @@ void compute_band_energies(const CELTMode *m, const celt_sig *X, celt_ener *band
* @param X Spectrum (returned normalised) * @param X Spectrum (returned normalised)
* @param bands Square root of the energy for each band * @param bands Square root of the energy for each band
*/ */
void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_norm * restrict X, const celt_ener *bands, int _C); void normalise_bands(const CELTMode *m, const celt_sig * restrict freq, celt_norm * restrict X, const celt_ener *bands, int _C, int M);
void renormalise_bands(const CELTMode *m, celt_norm * restrict X, int _C); void renormalise_bands(const CELTMode *m, celt_norm * restrict X, int _C, int M);
/** Denormalise each band of X to restore full amplitude /** Denormalise each band of X to restore full amplitude
* @param m Mode data * @param m Mode data
* @param X Spectrum (returned de-normalised) * @param X Spectrum (returned de-normalised)
* @param bands Square root of the energy for each band * @param bands Square root of the energy for each band
*/ */
void denormalise_bands(const CELTMode *m, const celt_norm * restrict X, celt_sig * restrict freq, const celt_ener *bands, int _C); void denormalise_bands(const CELTMode *m, const celt_norm * restrict X, celt_sig * restrict freq, const celt_ener *bands, int _C, int M);
/** Compute the pitch predictor gain for each pitch band /** Compute the pitch predictor gain for each pitch band
* @param m Mode data * @param m Mode data
@ -77,7 +77,7 @@ int compute_pitch_gain(const CELTMode *m, const celt_sig *X, const celt_sig *P,
void apply_pitch(const CELTMode *m, celt_sig *X, const celt_sig *P, int gain_id, int pred, int _C); void apply_pitch(const CELTMode *m, celt_sig *X, const celt_sig *P, int gain_id, int pred, int _C);
int folding_decision(const CELTMode *m, celt_norm *X, celt_word16 *average, int *last_decision, int _C); int folding_decision(const CELTMode *m, celt_norm *X, celt_word16 *average, int *last_decision, int _C, int M);
/** Quantisation/encoding of the residual spectrum /** Quantisation/encoding of the residual spectrum
* @param m Mode data * @param m Mode data
@ -85,9 +85,9 @@ int folding_decision(const CELTMode *m, celt_norm *X, celt_word16 *average, int
* @param total_bits Total number of bits that can be used for the frame (including the ones already spent) * @param total_bits Total number of bits that can be used for the frame (including the ones already spent)
* @param enc Entropy encoder * @param enc Entropy encoder
*/ */
void quant_bands(const CELTMode *m, int start, celt_norm * restrict X, const celt_ener *bandE, int *pulses, int time_domain, int fold, int resynth, int total_bits, int encode, void *enc_dec); void quant_bands(const CELTMode *m, int start, celt_norm * restrict X, const celt_ener *bandE, int *pulses, int time_domain, int fold, int resynth, int total_bits, int encode, void *enc_dec, int M);
void quant_bands_stereo(const CELTMode *m, int start, celt_norm * restrict X, const celt_ener *bandE, int *pulses, int time_domain, int fold, int resynth, int total_bits, ec_enc *enc); void quant_bands_stereo(const CELTMode *m, int start, celt_norm * restrict X, const celt_ener *bandE, int *pulses, int time_domain, int fold, int resynth, int total_bits, ec_enc *enc, int M);
/** Decoding of the residual spectrum /** Decoding of the residual spectrum
* @param m Mode data * @param m Mode data
@ -95,8 +95,8 @@ void quant_bands_stereo(const CELTMode *m, int start, celt_norm * restrict X, co
* @param total_bits Total number of bits that can be used for the frame (including the ones already spent) * @param total_bits Total number of bits that can be used for the frame (including the ones already spent)
* @param dec Entropy decoder * @param dec Entropy decoder
*/ */
void unquant_bands_stereo(const CELTMode *m, int start, celt_norm * restrict X, const celt_ener *bandE, int *pulses, int time_domain, int fold, int total_bits, ec_dec *dec); void unquant_bands_stereo(const CELTMode *m, int start, celt_norm * restrict X, const celt_ener *bandE, int *pulses, int time_domain, int fold, int total_bits, ec_dec *dec, int M);
void stereo_decision(const CELTMode *m, celt_norm * restrict X, int *stereo_mode, int len); void stereo_decision(const CELTMode *m, celt_norm * restrict X, int *stereo_mode, int len, int M);
#endif /* BANDS_H */ #endif /* BANDS_H */

38
libcelt/celt.c
View file

@ -531,7 +531,7 @@ void deemphasis(celt_sig *in, celt_word16 *pcm, int N, int _C, celt_word16 coef,
static void mdct_shape(const CELTMode *mode, celt_norm *X, int start, static void mdct_shape(const CELTMode *mode, celt_norm *X, int start,
int end, int N, int nbShortMdcts, int end, int N, int nbShortMdcts,
int mdct_weight_shift, int _C, int renorm) int mdct_weight_shift, int _C, int renorm, int M)
{ {
int m, i, c; int m, i, c;
const int C = CHANNELS(_C); const int C = CHANNELS(_C);
@ -544,7 +544,7 @@ static void mdct_shape(const CELTMode *mode, celt_norm *X, int start,
X[i] = (1.f/(1<<mdct_weight_shift))*X[i]; X[i] = (1.f/(1<<mdct_weight_shift))*X[i];
#endif #endif
if (renorm) if (renorm)
renormalise_bands(mode, X, C); renormalise_bands(mode, X, C, M);
} }
@ -585,6 +585,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig * pcm, celt_sig
int gain_id=0; int gain_id=0;
int norm_rate; int norm_rate;
int start=0; int start=0;
const int M=st->mode->nbShortMdcts;
SAVE_STACK; SAVE_STACK;
if (check_encoder(st) != CELT_OK) if (check_encoder(st) != CELT_OK)
@ -697,13 +698,13 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig * pcm, celt_sig
if (has_pitch) if (has_pitch)
apply_pitch(st->mode, freq, pitch_freq, gain_id, 1, C); apply_pitch(st->mode, freq, pitch_freq, gain_id, 1, C);
compute_band_energies(st->mode, freq, bandE, C); compute_band_energies(st->mode, freq, bandE, C, M);
for (i=0;i<st->mode->nbEBands*C;i++) for (i=0;i<st->mode->nbEBands*C;i++)
bandLogE[i] = amp2Log(bandE[i]); bandLogE[i] = amp2Log(bandE[i]);
/* Band normalisation */ /* Band normalisation */
normalise_bands(st->mode, freq, X, bandE, C); normalise_bands(st->mode, freq, X, bandE, C, M);
if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision, C)) if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision, C, M))
has_fold = 0; has_fold = 0;
/* Don't use intra energy when we're operating at low bit-rate */ /* Don't use intra energy when we're operating at low bit-rate */
@ -713,7 +714,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig * pcm, celt_sig
else else
st->delayedIntra = 0; st->delayedIntra = 0;
NN = st->mode->eBands[st->mode->nbEBands]; NN = M*st->mode->eBands[st->mode->nbEBands];
if (shortBlocks && !transient_shift) if (shortBlocks && !transient_shift)
{ {
celt_word32 sum[8]={1,1,1,1,1,1,1,1}; celt_word32 sum[8]={1,1,1,1,1,1,1,1};
@ -757,7 +758,7 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig * pcm, celt_sig
} while (m<st->mode->nbShortMdcts-1); } while (m<st->mode->nbShortMdcts-1);
#endif #endif
if (mdct_weight_shift) if (mdct_weight_shift)
mdct_shape(st->mode, X, mdct_weight_pos+1, st->mode->nbShortMdcts, N, st->mode->nbShortMdcts, mdct_weight_shift, C, 0); mdct_shape(st->mode, X, mdct_weight_pos+1, st->mode->nbShortMdcts, N, st->mode->nbShortMdcts, mdct_weight_shift, C, 0, M);
} }
@ -865,16 +866,16 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig * pcm, celt_sig
for (i=0;i<st->mode->nbEBands;i++) for (i=0;i<st->mode->nbEBands;i++)
offsets[i] = 0; offsets[i] = 0;
bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1; bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
compute_allocation(st->mode, start, offsets, bits, pulses, fine_quant, fine_priority, C); compute_allocation(st->mode, start, offsets, bits, pulses, fine_quant, fine_priority, C, M);
quant_fine_energy(st->mode, start, bandE, st->oldBandE, error, fine_quant, &enc, C); quant_fine_energy(st->mode, start, bandE, st->oldBandE, error, fine_quant, &enc, C);
/* Residual quantisation */ /* Residual quantisation */
if (C==1) if (C==1)
quant_bands(st->mode, start, X, bandE, pulses, shortBlocks, has_fold, resynth, nbCompressedBytes*8, 1, &enc); quant_bands(st->mode, start, X, bandE, pulses, shortBlocks, has_fold, resynth, nbCompressedBytes*8, 1, &enc, M);
#ifndef DISABLE_STEREO #ifndef DISABLE_STEREO
else else
quant_bands_stereo(st->mode, start, X, bandE, pulses, shortBlocks, has_fold, resynth, nbCompressedBytes*8, &enc); quant_bands_stereo(st->mode, start, X, bandE, pulses, shortBlocks, has_fold, resynth, nbCompressedBytes*8, &enc, M);
#endif #endif
quant_energy_finalise(st->mode, start, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc, C); quant_energy_finalise(st->mode, start, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc, C);
@ -887,11 +888,11 @@ int celt_encode_float(CELTEncoder * restrict st, const celt_sig * pcm, celt_sig
if (mdct_weight_shift) if (mdct_weight_shift)
{ {
mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C, 1); mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C, 1, M);
} }
/* Synthesis */ /* Synthesis */
denormalise_bands(st->mode, X, freq, bandE, C); denormalise_bands(st->mode, X, freq, bandE, C, M);
CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N)); CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
@ -1459,6 +1460,7 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
int mdct_weight_pos=0; int mdct_weight_pos=0;
int gain_id=0; int gain_id=0;
int start=0; int start=0;
const int M=st->mode->nbShortMdcts;
SAVE_STACK; SAVE_STACK;
if (check_decoder(st) != CELT_OK) if (check_decoder(st) != CELT_OK)
@ -1530,7 +1532,7 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
offsets[i] = 0; offsets[i] = 0;
bits = len*8 - ec_dec_tell(&dec, 0) - 1; bits = len*8 - ec_dec_tell(&dec, 0) - 1;
compute_allocation(st->mode, start, offsets, bits, pulses, fine_quant, fine_priority, C); compute_allocation(st->mode, start, offsets, bits, pulses, fine_quant, fine_priority, C, M);
/*bits = ec_dec_tell(&dec, 0); /*bits = ec_dec_tell(&dec, 0);
compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/ compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
@ -1545,20 +1547,20 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
/* Decode fixed codebook and merge with pitch */ /* Decode fixed codebook and merge with pitch */
if (C==1) if (C==1)
quant_bands(st->mode, start, X, bandE, pulses, shortBlocks, has_fold, 1, len*8, 0, &dec); quant_bands(st->mode, start, X, bandE, pulses, shortBlocks, has_fold, 1, len*8, 0, &dec, M);
#ifndef DISABLE_STEREO #ifndef DISABLE_STEREO
else else
unquant_bands_stereo(st->mode, start, X, bandE, pulses, shortBlocks, has_fold, len*8, &dec); unquant_bands_stereo(st->mode, start, X, bandE, pulses, shortBlocks, has_fold, len*8, &dec, M);
#endif #endif
unquant_energy_finalise(st->mode, start, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec, C); unquant_energy_finalise(st->mode, start, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec, C);
if (mdct_weight_shift) if (mdct_weight_shift)
{ {
mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C, 1); mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C, 1, M);
} }
/* Synthesis */ /* Synthesis */
denormalise_bands(st->mode, X, freq, bandE, C); denormalise_bands(st->mode, X, freq, bandE, C, M);
CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N)); CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
@ -1566,7 +1568,7 @@ int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int
if (has_pitch) if (has_pitch)
apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C); apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
for (i=0;i<st->mode->eBands[start];i++) for (i=0;i<M*st->mode->eBands[start];i++)
freq[i] = 0; freq[i] = 0;
/* Compute inverse MDCTs */ /* Compute inverse MDCTs */

35
libcelt/modes.c
View file

@ -119,14 +119,13 @@ static const int band_allocation[BARK_BANDS*BITALLOC_SIZE] =
static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int nbShortMdcts, int *nbEBands) static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int nbShortMdcts, int *nbEBands)
{ {
int min_bins = 2;
celt_int16 *eBands; celt_int16 *eBands;
int i, res, min_width, lin, low, high, nBark, offset=0; int i, res, min_width, lin, low, high, nBark, offset=0;
if (min_bins < nbShortMdcts) frame_size /= nbShortMdcts;
min_bins = nbShortMdcts; nbShortMdcts = 1;
res = (Fs+frame_size)/(2*frame_size); res = (Fs+frame_size)/(2*frame_size);
min_width = min_bins*res; min_width = res;
/* Find the number of critical bands supported by our sampling rate */ /* Find the number of critical bands supported by our sampling rate */
for (nBark=1;nBark<BARK_BANDS;nBark++) for (nBark=1;nBark<BARK_BANDS;nBark++)
@ -138,7 +137,7 @@ static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int nbShortMdct
if (bark_freq[lin+1]-bark_freq[lin] >= min_width) if (bark_freq[lin+1]-bark_freq[lin] >= min_width)
break; break;
low = (bark_freq[lin]+res*min_bins/2)/(res*min_bins); low = (bark_freq[lin]+res/2)/res;
high = nBark-lin; high = nBark-lin;
*nbEBands = low+high; *nbEBands = low+high;
eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+2)); eBands = celt_alloc(sizeof(celt_int16)*(*nbEBands+2));
@ -148,21 +147,21 @@ static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int nbShortMdct
/* Linear spacing (min_width) */ /* Linear spacing (min_width) */
for (i=0;i<low;i++) for (i=0;i<low;i++)
eBands[i] = min_bins*i; eBands[i] = i;
if (low>0) if (low>0)
offset = eBands[low-1]*res - bark_freq[lin-1]; offset = eBands[low-1]*res - bark_freq[lin-1];
/* Spacing follows critical bands */ /* Spacing follows critical bands */
for (i=0;i<high;i++) for (i=0;i<high;i++)
{ {
int target = bark_freq[lin+i]; int target = bark_freq[lin+i];
eBands[i+low] = (target+(offset+res*nbShortMdcts)/2)/(res*nbShortMdcts)*nbShortMdcts; eBands[i+low] = (target+(offset+res)/2)/res;
offset = eBands[i+low]*res - target; offset = eBands[i+low]*res - target;
} }
/* Enforce the minimum spacing at the boundary */ /* Enforce the minimum spacing at the boundary */
for (i=0;i<*nbEBands;i++) for (i=0;i<*nbEBands;i++)
if (eBands[i] < min_bins*i) if (eBands[i] < i)
eBands[i] = min_bins*i; eBands[i] = i;
eBands[*nbEBands] = (bark_freq[nBark]+res*nbShortMdcts/2)/(res*nbShortMdcts)*nbShortMdcts; eBands[*nbEBands] = (bark_freq[nBark]+res/2)/res;
eBands[*nbEBands+1] = frame_size; eBands[*nbEBands+1] = frame_size;
if (eBands[*nbEBands] > eBands[*nbEBands+1]) if (eBands[*nbEBands] > eBands[*nbEBands+1])
eBands[*nbEBands] = eBands[*nbEBands+1]; eBands[*nbEBands] = eBands[*nbEBands+1];
@ -170,10 +169,10 @@ static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int nbShortMdct
{ {
if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1]) if (eBands[i+1]-eBands[i] < eBands[i]-eBands[i-1])
{ {
eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1]+nbShortMdcts)/(2*nbShortMdcts)*nbShortMdcts; eBands[i] -= (2*eBands[i]-eBands[i-1]-eBands[i+1])/2;
} }
} }
/*for (i=0;i<*nbEBands+1;i++) /*for (i=0;i<=*nbEBands+1;i++)
printf ("%d ", eBands[i]); printf ("%d ", eBands[i]);
printf ("\n"); printf ("\n");
exit(1);*/ exit(1);*/
@ -181,7 +180,7 @@ static celt_int16 *compute_ebands(celt_int32 Fs, int frame_size, int nbShortMdct
return eBands; return eBands;
} }
static void compute_allocation_table(CELTMode *mode, int res) static void compute_allocation_table(CELTMode *mode, int res, int M)
{ {
int i, j, nBark; int i, j, nBark;
celt_int16 *allocVectors; celt_int16 *allocVectors;
@ -209,7 +208,7 @@ static void compute_allocation_table(CELTMode *mode, int res)
low = bark_freq[j]; low = bark_freq[j];
high = bark_freq[j+1]; high = bark_freq[j+1];
edge = mode->eBands[eband+1]*res; edge = M*mode->eBands[eband+1]*res;
while (edge <= high && eband < mode->nbEBands) while (edge <= high && eband < mode->nbEBands)
{ {
celt_int32 num; celt_int32 num;
@ -227,7 +226,7 @@ static void compute_allocation_table(CELTMode *mode, int res)
/* Move to next eband */ /* Move to next eband */
current = 0; current = 0;
eband++; eband++;
edge = mode->eBands[eband+1]*res; edge = M*mode->eBands[eband+1]*res;
} }
current += alloc; current += alloc;
} }
@ -361,7 +360,7 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
else else
mode->overlap = (frame_size>>3)<<2; mode->overlap = (frame_size>>3)<<2;
compute_allocation_table(mode, res); compute_allocation_table(mode, res, mode->nbShortMdcts);
if (mode->allocVectors==NULL) if (mode->allocVectors==NULL)
goto failure; goto failure;
@ -378,7 +377,7 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
#endif #endif
mode->window = window; mode->window = window;
mode->bits = (const celt_int16 **)compute_alloc_cache(mode, 1); mode->bits = (const celt_int16 **)compute_alloc_cache(mode, 1, mode->nbShortMdcts);
if (mode->bits==NULL) if (mode->bits==NULL)
goto failure; goto failure;
@ -387,7 +386,7 @@ CELTMode *celt_mode_create(celt_int32 Fs, int frame_size, int *error)
goto failure; goto failure;
for (i=0;i<mode->nbEBands;i++) for (i=0;i<mode->nbEBands;i++)
logN[i] = log2_frac(mode->eBands[i+1]-mode->eBands[i], BITRES); logN[i] = log2_frac(mode->nbShortMdcts*(mode->eBands[i+1]-mode->eBands[i]), BITRES);
mode->logN = logN; mode->logN = logN;
#endif /* !STATIC_MODES */ #endif /* !STATIC_MODES */

14
libcelt/rate.c
View file

@ -46,7 +46,7 @@
#ifndef STATIC_MODES #ifndef STATIC_MODES
celt_int16 **compute_alloc_cache(CELTMode *m, int C) celt_int16 **compute_alloc_cache(CELTMode *m, int C, int M)
{ {
int i, prevN; int i, prevN;
int error = 0; int error = 0;
@ -60,8 +60,8 @@ celt_int16 **compute_alloc_cache(CELTMode *m, int C)
prevN = -1; prevN = -1;
for (i=0;i<m->nbEBands;i++) for (i=0;i<m->nbEBands;i++)
{ {
int N = C*(eBands[i+1]-eBands[i]); int N = C*M*(eBands[i+1]-eBands[i]);
if (N == prevN && eBands[i] < m->pitchEnd) if (N == prevN && M*eBands[i] < m->pitchEnd)
{ {
bits[i] = bits[i-1]; bits[i] = bits[i-1];
} else { } else {
@ -102,7 +102,7 @@ celt_int16 **compute_alloc_cache(CELTMode *m, int C)
static inline void interp_bits2pulses(const CELTMode *m, int start, int *bits1, int *bits2, int total, int *bits, int *ebits, int *fine_priority, int len, int _C) static inline void interp_bits2pulses(const CELTMode *m, int start, int *bits1, int *bits2, int total, int *bits, int *ebits, int *fine_priority, int len, int _C, int M)
{ {
int psum; int psum;
int lo, hi; int lo, hi;
@ -145,7 +145,7 @@ static inline void interp_bits2pulses(const CELTMode *m, int start, int *bits1,
int N, d; int N, d;
int offset; int offset;
N=m->eBands[j+1]-m->eBands[j]; N=M*(m->eBands[j+1]-m->eBands[j]);
/* Compensate for the extra DoF in stereo */ /* Compensate for the extra DoF in stereo */
d=(C*N+ ((C==2 && N>2) ? 1 : 0))<<BITRES; d=(C*N+ ((C==2 && N>2) ? 1 : 0))<<BITRES;
offset = FINE_OFFSET - m->logN[j]; offset = FINE_OFFSET - m->logN[j];
@ -173,7 +173,7 @@ static inline void interp_bits2pulses(const CELTMode *m, int start, int *bits1,
RESTORE_STACK; RESTORE_STACK;
} }
void compute_allocation(const CELTMode *m, int start, int *offsets, int total, int *pulses, int *ebits, int *fine_priority, int _C) void compute_allocation(const CELTMode *m, int start, int *offsets, int total, int *pulses, int *ebits, int *fine_priority, int _C, int M)
{ {
int lo, hi, len, j; int lo, hi, len, j;
const int C = CHANNELS(_C); const int C = CHANNELS(_C);
@ -216,7 +216,7 @@ void compute_allocation(const CELTMode *m, int start, int *offsets, int total, i
if (bits2[j] < 0) if (bits2[j] < 0)
bits2[j] = 0; bits2[j] = 0;
} }
interp_bits2pulses(m, start, bits1, bits2, total, pulses, ebits, fine_priority, len, C); interp_bits2pulses(m, start, bits1, bits2, total, pulses, ebits, fine_priority, len, C, M);
RESTORE_STACK; RESTORE_STACK;
} }

4
libcelt/rate.h
View file

@ -155,7 +155,7 @@ static inline int pulses2bits(const celt_int16 *cache, int N, int pulses)
} }
/** Computes a cache of the pulses->bits mapping in each band */ /** Computes a cache of the pulses->bits mapping in each band */
celt_int16 **compute_alloc_cache(CELTMode *m, int C); celt_int16 **compute_alloc_cache(CELTMode *m, int C, int M);
/** Compute the pulse allocation, i.e. how many pulses will go in each /** Compute the pulse allocation, i.e. how many pulses will go in each
* band. * band.
@ -166,7 +166,7 @@ celt_int16 **compute_alloc_cache(CELTMode *m, int C);
@param pulses Number of pulses per band (returned) @param pulses Number of pulses per band (returned)
@return Total number of bits allocated @return Total number of bits allocated
*/ */
void compute_allocation(const CELTMode *m, int start, int *offsets, int total, int *pulses, int *ebits, int *fine_priority, int _C); void compute_allocation(const CELTMode *m, int start, int *offsets, int total, int *pulses, int *ebits, int *fine_priority, int _C, int M);
#endif #endif

8
libcelt/vq.c
View file

@ -473,11 +473,11 @@ celt_word16 renormalise_vector(celt_norm *X, celt_word16 value, int N, int strid
return celt_sqrt(E); return celt_sqrt(E);
} }
static void fold(const CELTMode *m, int start, int N, const celt_norm * restrict Y, celt_norm * restrict P, int N0, int B) static void fold(const CELTMode *m, int start, int N, const celt_norm * restrict Y, celt_norm * restrict P, int N0, int B, int M)
{ {
int j; int j;
int id = N0 % B; int id = N0 % B;
while (id < m->eBands[start]) while (id < M*m->eBands[start])
id += B; id += B;
/* Here, we assume that id will never be greater than N0, i.e. that /* Here, we assume that id will never be greater than N0, i.e. that
no band is wider than N0. In the unlikely case it happens, we set no band is wider than N0. In the unlikely case it happens, we set
@ -500,9 +500,9 @@ static void fold(const CELTMode *m, int start, int N, const celt_norm * restrict
P[j] = Y[id++]; P[j] = Y[id++];
} }
void intra_fold(const CELTMode *m, int start, int N, const celt_norm * restrict Y, celt_norm * restrict P, int N0, int B) void intra_fold(const CELTMode *m, int start, int N, const celt_norm * restrict Y, celt_norm * restrict P, int N0, int B, int M)
{ {
fold(m, start, N, Y, P, N0, B); fold(m, start, N, Y, P, N0, B, M);
renormalise_vector(P, Q15ONE, N, 1); renormalise_vector(P, Q15ONE, N, 1);
} }

2
libcelt/vq.h
View file

@ -75,6 +75,6 @@ celt_word16 renormalise_vector(celt_norm *X, celt_word16 value, int N, int strid
* @param B Stride (number of channels multiplied by the number of MDCTs per frame) * @param B Stride (number of channels multiplied by the number of MDCTs per frame)
* @param N0 Number of valid offsets * @param N0 Number of valid offsets
*/ */
void intra_fold(const CELTMode *m, int start, int N, const celt_norm * restrict Y, celt_norm * restrict P, int N0, int B); void intra_fold(const CELTMode *m, int start, int N, const celt_norm * restrict Y, celt_norm * restrict P, int N0, int B, int M);
#endif /* VQ_H */ #endif /* VQ_H */