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

Removed support for more than one MDCT blocks per frame. I don't think there's

Browse source 
a use for that anymore now that the overlap can be less than one frame.
This commit is contained in:
Jean-Marc Valin 2008-03-25 14:38:55 +11:00
parent bd718ba577
commit b886ddc08c
1 changed files with 88 additions and 112 deletions
Download patch file Download diff file Expand all files Collapse all files

118
libcelt/celt.c
View file

@ -60,7 +60,6 @@ struct CELTEncoder {
const CELTMode *mode; /**< Mode used by the encoder */ const CELTMode *mode; /**< Mode used by the encoder */
int frame_size; int frame_size;
int block_size; int block_size;
int nb_blocks;
int overlap; int overlap;
int channels; int channels;
@ -81,21 +80,19 @@ struct CELTEncoder {
CELTEncoder EXPORT *celt_encoder_create(const CELTMode *mode) CELTEncoder EXPORT *celt_encoder_create(const CELTMode *mode)
{ {
int N, B, C; int N, C;
CELTEncoder *st; CELTEncoder *st;
if (check_mode(mode) != CELT_OK) if (check_mode(mode) != CELT_OK)
return NULL; return NULL;
N = mode->mdctSize; N = mode->mdctSize;
B = mode->nbMdctBlocks;
C = mode->nbChannels; C = mode->nbChannels;
st = celt_alloc(sizeof(CELTEncoder)); st = celt_alloc(sizeof(CELTEncoder));
st->mode = mode; st->mode = mode;
st->frame_size = B*N; st->frame_size = N;
st->block_size = N; st->block_size = N;
st->nb_blocks = B;
st->overlap = mode->overlap; st->overlap = mode->overlap;
ec_byte_writeinit(&st->buf); ec_byte_writeinit(&st->buf);
@ -156,9 +153,9 @@ static inline celt_int16_t SIG2INT16(celt_sig_t x)
} }
/** Apply window and compute the MDCT for all sub-frames and all channels in a frame */ /** Apply window and compute the MDCT for all sub-frames and all channels in a frame */
static celt_word32_t compute_mdcts(const mdct_lookup *lookup, const celt_word16_t * restrict window, celt_sig_t * restrict in, celt_sig_t * restrict out, int N, int overlap, int B, int C) static celt_word32_t compute_mdcts(const mdct_lookup *lookup, const celt_word16_t * restrict window, celt_sig_t * restrict in, celt_sig_t * restrict out, int N, int overlap, int C)
{ {
int i, c, N4; int c, N4;
celt_word32_t E = 0; celt_word32_t E = 0;
VARDECL(celt_word32_t, x); VARDECL(celt_word32_t, x);
VARDECL(celt_word32_t, tmp); VARDECL(celt_word32_t, tmp);
@ -167,13 +164,11 @@ static celt_word32_t compute_mdcts(const mdct_lookup *lookup, const celt_word16_
ALLOC(x, 2*N, celt_word32_t); ALLOC(x, 2*N, celt_word32_t);
ALLOC(tmp, N, celt_word32_t); ALLOC(tmp, N, celt_word32_t);
for (c=0;c<C;c++) for (c=0;c<C;c++)
{
for (i=0;i<B;i++)
{ {
int j; int j;
celt_word32_t * restrict x1, * restrict x2; celt_word32_t * restrict x1, * restrict x2;
for (j=0;j<2*N-2*N4;j++) for (j=0;j<2*N-2*N4;j++)
x[j+N4] = in[C*i*N+C*j+c]; x[j+N4] = in[C*j+c];
x1 = x+N4; x1 = x+N4;
x2 = x+2*N-N4-1; x2 = x+2*N-N4-1;
for (j=0;j<overlap;j++) for (j=0;j<overlap;j++)
@ -193,17 +188,16 @@ static celt_word32_t compute_mdcts(const mdct_lookup *lookup, const celt_word16_
mdct_forward(lookup, x, tmp); mdct_forward(lookup, x, tmp);
/* Interleaving the sub-frames */ /* Interleaving the sub-frames */
for (j=0;j<N;j++) for (j=0;j<N;j++)
out[C*B*j+C*i+c] = tmp[j]; out[C*j+c] = tmp[j];
}
} }
RESTORE_STACK; RESTORE_STACK;
return E; return E;
} }
/** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */ /** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
static void compute_inv_mdcts(const mdct_lookup *lookup, const celt_word16_t * restrict window, celt_sig_t *X, celt_sig_t * restrict out_mem, celt_sig_t * restrict mdct_overlap, int N, int overlap, int B, int C) static void compute_inv_mdcts(const mdct_lookup *lookup, const celt_word16_t * restrict window, celt_sig_t *X, celt_sig_t * restrict out_mem, celt_sig_t * restrict mdct_overlap, int N, int overlap, int C)
{ {
int i, c, N4; int c, N4;
VARDECL(celt_word32_t, x); VARDECL(celt_word32_t, x);
VARDECL(celt_word32_t, tmp); VARDECL(celt_word32_t, tmp);
SAVE_STACK; SAVE_STACK;
@ -211,30 +205,27 @@ static void compute_inv_mdcts(const mdct_lookup *lookup, const celt_word16_t * r
ALLOC(tmp, N, celt_word32_t); ALLOC(tmp, N, celt_word32_t);
N4 = (N-overlap)>>1; N4 = (N-overlap)>>1;
for (c=0;c<C;c++) for (c=0;c<C;c++)
{
for (i=0;i<B;i++)
{ {
int j; int j;
/* De-interleaving the sub-frames */ /* De-interleaving the sub-frames */
for (j=0;j<N;j++) for (j=0;j<N;j++)
tmp[j] = X[C*B*j+C*i+c]; tmp[j] = X[C*j+c];
mdct_backward(lookup, tmp, x); mdct_backward(lookup, tmp, x);
/* The first and last part would need to be set to zero if we actually /* The first and last part would need to be set to zero if we actually
wanted to use them. */ wanted to use them. */
for (j=0;j<overlap;j++) for (j=0;j<overlap;j++)
out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c] = 2*(mdct_overlap[C*j+c]+MULT16_32_Q15(window[j],x[j+N4])); out_mem[C*(MAX_PERIOD-N)+C*j+c] = 2*(mdct_overlap[C*j+c]+MULT16_32_Q15(window[j],x[j+N4]));
for (j=0;j<overlap;j++) for (j=0;j<overlap;j++)
mdct_overlap[C*(overlap-j-1)+c] = MULT16_32_Q15(window[j],x[2*N-j-N4-1]); mdct_overlap[C*(overlap-j-1)+c] = MULT16_32_Q15(window[j],x[2*N-j-N4-1]);
for (j=0;j<2*N4;j++) for (j=0;j<2*N4;j++)
out_mem[C*(MAX_PERIOD+(i-B)*N)+C*(j+overlap)+c] = 2*x[j+N4+overlap]; out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = 2*x[j+N4+overlap];
}
} }
RESTORE_STACK; RESTORE_STACK;
} }
int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compressed, int nbCompressedBytes) int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compressed, int nbCompressedBytes)
{ {
int i, c, N, B, C, N4; int i, c, N, C, N4;
int has_pitch; int has_pitch;
int pitch_index; int pitch_index;
celt_word32_t curr_power, pitch_power; celt_word32_t curr_power, pitch_power;
@ -250,33 +241,32 @@ int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compre
return CELT_INVALID_MODE; return CELT_INVALID_MODE;
N = st->block_size; N = st->block_size;
B = st->nb_blocks;
C = st->mode->nbChannels; C = st->mode->nbChannels;
N4 = (N-st->overlap)>>1; N4 = (N-st->overlap)>>1;
ALLOC(in, (B+1)*C*N-2*N4, celt_sig_t); ALLOC(in, 2*C*N-2*N4, celt_sig_t);
for (c=0;c<C;c++) for (c=0;c<C;c++)
{ {
for (i=0;i<st->overlap;i++) for (i=0;i<st->overlap;i++)
in[C*i+c] = st->in_mem[C*i+c]; in[C*i+c] = st->in_mem[C*i+c];
for (i=0;i<B*N;i++) for (i=0;i<N;i++)
{ {
celt_sig_t tmp = SHL32(EXTEND32(pcm[C*i+c]), SIG_SHIFT); celt_sig_t tmp = SHL32(EXTEND32(pcm[C*i+c]), SIG_SHIFT);
in[C*(i+st->overlap)+c] = SUB32(tmp, MULT16_32_Q15(preemph,st->preemph_memE[c])); in[C*(i+st->overlap)+c] = SUB32(tmp, MULT16_32_Q15(preemph,st->preemph_memE[c]));
st->preemph_memE[c] = tmp; st->preemph_memE[c] = tmp;
} }
for (i=0;i<st->overlap;i++) for (i=0;i<st->overlap;i++)
st->in_mem[C*i+c] = in[C*(N*(B+1)-2*N4-st->overlap+i)+c]; st->in_mem[C*i+c] = in[C*(2*N-2*N4-st->overlap+i)+c];
} }
/* Pitch analysis: we do it early to save on the peak stack space */ /* Pitch analysis: we do it early to save on the peak stack space */
find_spectral_pitch(st->fft, &st->mode->psy, in, st->out_mem, st->mode->window, st->overlap, MAX_PERIOD, (B+1)*N-2*N4, C, &pitch_index); find_spectral_pitch(st->fft, &st->mode->psy, in, st->out_mem, st->mode->window, st->overlap, MAX_PERIOD, 2*N-2*N4, C, &pitch_index);
ALLOC(freq, B*C*N, celt_sig_t); /**< Interleaved signal MDCTs */ ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
/*for (i=0;i<(B+1)*C*N;i++) printf ("%f(%d) ", in[i], i); printf ("\n");*/ /*for (i=0;i<(B+1)*C*N;i++) printf ("%f(%d) ", in[i], i); printf ("\n");*/
/* Compute MDCTs */ /* Compute MDCTs */
curr_power = compute_mdcts(&st->mode->mdct, st->mode->window, in, freq, N, st->overlap, B, C); curr_power = compute_mdcts(&st->mode->mdct, st->mode->window, in, freq, N, st->overlap, C);
#if 0 /* Mask disabled until it can be made to do something useful */ #if 0 /* Mask disabled until it can be made to do something useful */
compute_mdct_masking(X, mask, B*C*N, st->Fs); compute_mdct_masking(X, mask, B*C*N, st->Fs);
@ -289,8 +279,8 @@ int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compre
#endif #endif
/* Deferred allocation after find_spectral_pitch() to reduce the peak memory usage */ /* Deferred allocation after find_spectral_pitch() to reduce the peak memory usage */
ALLOC(X, B*C*N, celt_norm_t); /**< Interleaved normalised MDCTs */ ALLOC(X, C*N, celt_norm_t); /**< Interleaved normalised MDCTs */
ALLOC(P, B*C*N, celt_norm_t); /**< Interleaved normalised pitch MDCTs*/ ALLOC(P, C*N, celt_norm_t); /**< Interleaved normalised pitch MDCTs*/
ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t); ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
ALLOC(gains,st->mode->nbPBands, celt_pgain_t); ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
@ -309,7 +299,7 @@ int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compre
/*for (i=0;i<N*B*C;i++)printf("%f ", X[i]);printf("\n");*/ /*for (i=0;i<N*B*C;i++)printf("%f ", X[i]);printf("\n");*/
/* Compute MDCTs of the pitch part */ /* Compute MDCTs of the pitch part */
pitch_power = compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, B, C); pitch_power = compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, C);
quant_energy(st->mode, bandE, st->oldBandE, nbCompressedBytes*8/3, &st->enc); quant_energy(st->mode, bandE, st->oldBandE, nbCompressedBytes*8/3, &st->enc);
@ -338,13 +328,13 @@ int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compre
compute_pitch_gain(st->mode, X, P, gains); compute_pitch_gain(st->mode, X, P, gains);
has_pitch = quant_pitch(gains, st->mode->nbPBands, &st->enc); has_pitch = quant_pitch(gains, st->mode->nbPBands, &st->enc);
if (has_pitch) if (has_pitch)
ec_enc_uint(&st->enc, pitch_index, MAX_PERIOD-((B+1)*N-2*N4)); ec_enc_uint(&st->enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
} else { } else {
/* No pitch, so we just pretend we found a gain of zero */ /* No pitch, so we just pretend we found a gain of zero */
for (i=0;i<st->mode->nbPBands;i++) for (i=0;i<st->mode->nbPBands;i++)
gains[i] = 0; gains[i] = 0;
ec_enc_uint(&st->enc, 0, 128); ec_enc_uint(&st->enc, 0, 128);
for (i=0;i<B*C*N;i++) for (i=0;i<C*N;i++)
P[i] = 0; P[i] = 0;
} }
@ -353,7 +343,7 @@ int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compre
/*for (i=0;i<B*N;i++) printf("%f ",P[i]);printf("\n");*/ /*for (i=0;i<B*N;i++) printf("%f ",P[i]);printf("\n");*/
/* Compute residual that we're going to encode */ /* Compute residual that we're going to encode */
for (i=0;i<B*C*N;i++) for (i=0;i<C*N;i++)
X[i] -= P[i]; X[i] -= P[i];
/* Residual quantisation */ /* Residual quantisation */
@ -368,22 +358,19 @@ int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compre
denormalise_bands(st->mode, X, freq, bandE); denormalise_bands(st->mode, X, freq, bandE);
CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N)); CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD-N));
compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C); compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, C);
/* De-emphasis and put everything back at the right place in the synthesis history */ /* De-emphasis and put everything back at the right place in the synthesis history */
for (c=0;c<C;c++) for (c=0;c<C;c++)
{
for (i=0;i<B;i++)
{ {
int j; int j;
for (j=0;j<N;j++) for (j=0;j<N;j++)
{ {
celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c], celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
MULT16_32_Q15(preemph,st->preemph_memD[c])); MULT16_32_Q15(preemph,st->preemph_memD[c]));
st->preemph_memD[c] = tmp; st->preemph_memD[c] = tmp;
pcm[C*i*N+C*j+c] = SIG2INT16(tmp); pcm[C*j+c] = SIG2INT16(tmp);
}
} }
} }
@ -439,7 +426,6 @@ struct CELTDecoder {
const CELTMode *mode; const CELTMode *mode;
int frame_size; int frame_size;
int block_size; int block_size;
int nb_blocks;
int overlap; int overlap;
ec_byte_buffer buf; ec_byte_buffer buf;
@ -457,21 +443,19 @@ struct CELTDecoder {
CELTDecoder EXPORT *celt_decoder_create(const CELTMode *mode) CELTDecoder EXPORT *celt_decoder_create(const CELTMode *mode)
{ {
int N, B, C; int N, C;
CELTDecoder *st; CELTDecoder *st;
if (check_mode(mode) != CELT_OK) if (check_mode(mode) != CELT_OK)
return NULL; return NULL;
N = mode->mdctSize; N = mode->mdctSize;
B = mode->nbMdctBlocks;
C = mode->nbChannels; C = mode->nbChannels;
st = celt_alloc(sizeof(CELTDecoder)); st = celt_alloc(sizeof(CELTDecoder));
st->mode = mode; st->mode = mode;
st->frame_size = B*N; st->frame_size = N;
st->block_size = N; st->block_size = N;
st->nb_blocks = B;
st->overlap = mode->overlap; st->overlap = mode->overlap;
st->mdct_overlap = celt_alloc(N*C*sizeof(celt_sig_t)); st->mdct_overlap = celt_alloc(N*C*sizeof(celt_sig_t));
@ -510,36 +494,32 @@ void EXPORT celt_decoder_destroy(CELTDecoder *st)
pitch period */ pitch period */
static void celt_decode_lost(CELTDecoder *st, short *pcm) static void celt_decode_lost(CELTDecoder *st, short *pcm)
{ {
int i, c, N, B, C; int c, N, C;
int pitch_index; int pitch_index;
VARDECL(celt_sig_t, freq); VARDECL(celt_sig_t, freq);
SAVE_STACK; SAVE_STACK;
N = st->block_size; N = st->block_size;
B = st->nb_blocks;
C = st->mode->nbChannels; C = st->mode->nbChannels;
ALLOC(freq,C*B*N, celt_sig_t); /**< Interleaved signal MDCTs */ ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
pitch_index = st->last_pitch_index; pitch_index = st->last_pitch_index;
/* Use the pitch MDCT as the "guessed" signal */ /* Use the pitch MDCT as the "guessed" signal */
compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, B, C); compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, C);
CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N)); CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD-N));
/* Compute inverse MDCTs */ /* Compute inverse MDCTs */
compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C); compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, C);
for (c=0;c<C;c++) for (c=0;c<C;c++)
{
for (i=0;i<B;i++)
{ {
int j; int j;
for (j=0;j<N;j++) for (j=0;j<N;j++)
{ {
celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c], celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
MULT16_32_Q15(preemph,st->preemph_memD[c])); MULT16_32_Q15(preemph,st->preemph_memD[c]));
st->preemph_memD[c] = tmp; st->preemph_memD[c] = tmp;
pcm[C*i*N+C*j+c] = SIG2INT16(tmp); pcm[C*j+c] = SIG2INT16(tmp);
}
} }
} }
RESTORE_STACK; RESTORE_STACK;
@ -547,7 +527,7 @@ static void celt_decode_lost(CELTDecoder *st, short *pcm)
int EXPORT celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16_t *pcm) int EXPORT celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16_t *pcm)
{ {
int i, c, N, B, C, N4; int c, N, C, N4;
int has_pitch; int has_pitch;
int pitch_index; int pitch_index;
ec_dec dec; ec_dec dec;
@ -563,13 +543,12 @@ int EXPORT celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16
return CELT_INVALID_MODE; return CELT_INVALID_MODE;
N = st->block_size; N = st->block_size;
B = st->nb_blocks;
C = st->mode->nbChannels; C = st->mode->nbChannels;
N4 = (N-st->overlap)>>1; N4 = (N-st->overlap)>>1;
ALLOC(freq, C*B*N, celt_sig_t); /**< Interleaved signal MDCTs */ ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
ALLOC(X, C*B*N, celt_norm_t); /**< Interleaved normalised MDCTs */ ALLOC(X, C*N, celt_norm_t); /**< Interleaved normalised MDCTs */
ALLOC(P, C*B*N, celt_norm_t); /**< Interleaved normalised pitch MDCTs*/ ALLOC(P, C*N, celt_norm_t); /**< Interleaved normalised pitch MDCTs*/
ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t); ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
ALLOC(gains, st->mode->nbPBands, celt_pgain_t); ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
@ -597,7 +576,7 @@ int EXPORT celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16
/* Get the pitch index */ /* Get the pitch index */
if (has_pitch) if (has_pitch)
{ {
pitch_index = ec_dec_uint(&dec, MAX_PERIOD-((B+1)*N-2*N4)); pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
st->last_pitch_index = pitch_index; st->last_pitch_index = pitch_index;
} else { } else {
/* FIXME: We could be more intelligent here and just not compute the MDCT */ /* FIXME: We could be more intelligent here and just not compute the MDCT */
@ -605,7 +584,7 @@ int EXPORT celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16
} }
/* Pitch MDCT */ /* Pitch MDCT */
compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, B, C); compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, C);
{ {
VARDECL(celt_ener_t, bandEp); VARDECL(celt_ener_t, bandEp);
@ -632,22 +611,19 @@ int EXPORT celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16
denormalise_bands(st->mode, X, freq, bandE); denormalise_bands(st->mode, X, freq, bandE);
CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N)); CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD-N));
/* Compute inverse MDCTs */ /* Compute inverse MDCTs */
compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C); compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, C);
for (c=0;c<C;c++) for (c=0;c<C;c++)
{
for (i=0;i<B;i++)
{ {
int j; int j;
for (j=0;j<N;j++) for (j=0;j<N;j++)
{ {
celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c], celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
MULT16_32_Q15(preemph,st->preemph_memD[c])); MULT16_32_Q15(preemph,st->preemph_memD[c]));
st->preemph_memD[c] = tmp; st->preemph_memD[c] = tmp;
pcm[C*i*N+C*j+c] = SIG2INT16(tmp); pcm[C*j+c] = SIG2INT16(tmp);
}
} }
} }