void
fill_buffer(lame_global_flags const *gfp,
sample_t * mfbuf[2], sample_t const *in_buffer[2], int nsamples, int *n_in, int *n_out)
{
lame_internal_flags const *const gfc = gfp->internal_flags;
int ch, i;
/* copy in new samples into mfbuf, with resampling if necessary */
if ((gfc->resample_ratio < .9999) || (gfc->resample_ratio > 1.0001)) {
for (ch = 0; ch < gfc->channels_out; ch++) {
*n_out =
fill_buffer_resample(gfp, &mfbuf[ch][gfc->mf_size],
gfp->framesize, in_buffer[ch], nsamples, n_in, ch);
}
}
else {
*n_out = Min(gfp->framesize, nsamples);
*n_in = *n_out;
for (i = 0; i < *n_out; ++i) {
mfbuf[0][gfc->mf_size + i] = in_buffer[0][i];
if (gfc->channels_out == 2)
mfbuf[1][gfc->mf_size + i] = in_buffer[1][i];
}
}
}
/*
* THE MAIN LAME ENCODING INTERFACE
* mt 3/00
*
* input pcm data, output (maybe) mp3 frames.
* This routine handles all buffering, resampling and filtering for you.
* The required mp3buffer_size can be computed from num_samples,
* samplerate and encoding rate, but here is a worst case estimate:
*
* mp3buffer_size in bytes = 1.25*num_samples + 7200
*
* return code = number of bytes output in mp3buffer. can be 0
*/
int lame_encode_buffer(lame_global_flags *gfp,
short int buffer_l[], short int buffer_r[],int nsamples,
char *mp3buf, int mp3buf_size)
{
static int frame_buffered=0;
int mp3size=0,ret,i,ch,mf_needed;
short int *in_buffer[2];
in_buffer[0] = buffer_l;
in_buffer[1] = buffer_r;
/* some sanity checks */
assert(ENCDELAY>=MDCTDELAY);
assert(BLKSIZE-FFTOFFSET >= 0);
mf_needed = BLKSIZE+gfp->framesize-FFTOFFSET;
assert(MFSIZE>=mf_needed);
/* The reason for
* int mf_samples_to_encode = ENCDELAY + 288;
* ENCDELAY = internal encoder delay. And then we have to add 288
* because of the 50% MDCT overlap. A 576 MDCT granule decodes to
* 1152 samples. To synthesize the 576 samples centered under this granule
* we need the previous granule for the first 288 samples (no problem), and
* the next granule for the next 288 samples (not possible if this is last
* granule). So we need to pad with 288 samples to make sure we can
* encode the 576 samples we are interested in.
*/
if (gfp->frameNum==0 && !frame_buffered) {
memset((char *) mfbuf, 0, sizeof(mfbuf));
frame_buffered=1;
mf_samples_to_encode = ENCDELAY+288;
mf_size=ENCDELAY-MDCTDELAY; /* we pad input with this many 0's */
}
if (gfp->frameNum==1) {
/* reset, for the next time frameNum==0 */
frame_buffered=0;
}
if (gfp->num_channels==2 && gfp->stereo==1) {
/* downsample to mono */
for (i=0; i<nsamples; ++i) {
in_buffer[0][i]=((int)in_buffer[0][i]+(int)in_buffer[1][i])/2;
in_buffer[1][i]=0;
}
}
while (nsamples > 0) {
int n_in=0;
int n_out=0;
/* copy in new samples */
for (ch=0; ch<gfp->stereo; ch++) {
if (gfp->resample_ratio!=1) {
n_out=fill_buffer_resample(gfp,&mfbuf[ch][mf_size],gfp->framesize,
in_buffer[ch],nsamples,&n_in,ch);
} else {
n_out=fill_buffer(gfp,&mfbuf[ch][mf_size],gfp->framesize,in_buffer[ch],nsamples);
n_in = n_out;
}
in_buffer[ch] += n_in;
}
nsamples -= n_in;
mf_size += n_out;
assert(mf_size<=MFSIZE);
mf_samples_to_encode += n_out;
if (mf_size >= mf_needed) {
/* encode the frame */
ret = lame_encode_frame(gfp,mfbuf[0],mfbuf[1],mf_size,mp3buf,mp3buf_size);
if (ret == -1) {
/* fatel error: mp3buffer was too small */
return -1;
}
mp3buf += ret;
mp3size += ret;
/* shift out old samples */
mf_size -= gfp->framesize;
mf_samples_to_encode -= gfp->framesize;
for (ch=0; ch<gfp->stereo; ch++)
for (i=0; i<mf_size; i++)
mfbuf[ch][i]=mfbuf[ch][i+gfp->framesize];
}
}
assert(nsamples==0);
return mp3size;
}
