int lame_encode_mp3_frame ( // Output
lame_global_flags* const gfp, // Context
sample_t* inbuf_l, // Input
sample_t* inbuf_r, // Input
unsigned char* mp3buf, // Output
int mp3buf_size ) // Output
{
#ifdef macintosh /* PLL 14/04/2000 */
static FLOAT8 xr[2][2][576];
static int l3_enc[2][2][576];
#else
FLOAT8 xr[2][2][576];
int l3_enc[2][2][576];
#endif
int mp3count;
III_psy_ratio masking_LR[2][2]; /*LR masking & energy */
III_psy_ratio masking_MS[2][2]; /*MS masking & energy */
III_psy_ratio (*masking)[2][2]; /*pointer to selected maskings*/
III_scalefac_t scalefac[2][2];
const sample_t *inbuf[2];
lame_internal_flags *gfc=gfp->internal_flags;
FLOAT8 tot_ener[2][4];
FLOAT8 ms_ener_ratio[2]={.5,.5};
chgrdata pe,pe_MS;
chgrdata *pe_use;
int ch,gr,mean_bits;
int bitsPerFrame;
int check_ms_stereo;
FLOAT8 ms_ratio_next = 0.;
FLOAT8 ms_ratio_prev = 0.;
memset((char *) masking_LR, 0, sizeof(masking_LR));
memset((char *) masking_MS, 0, sizeof(masking_MS));
memset((char *) scalefac, 0, sizeof(scalefac));
inbuf[0]=inbuf_l;
inbuf[1]=inbuf_r;
check_ms_stereo = (gfp->mode == JOINT_STEREO);
gfc->mode_ext = MPG_MD_LR_LR;
if (gfc->lame_encode_frame_init==0 ) {
gfc->lame_encode_frame_init=1;
/* padding method as described in
* "MPEG-Layer3 / Bitstream Syntax and Decoding"
* by Martin Sieler, Ralph Sperschneider
*
* note: there is no padding for the very first frame
*
* [email protected] 2000-06-22
*/
gfc->frac_SpF = ((gfp->version+1)*72000L*gfp->brate) % gfp->out_samplerate;
gfc->slot_lag = gfc->frac_SpF;
/* check FFT will not use a negative starting offset */
#if 576 < FFTOFFSET
# error FFTOFFSET greater than 576: FFT uses a negative offset
#endif
/* check if we have enough data for FFT */
assert(gfc->mf_size>=(BLKSIZE+gfp->framesize-FFTOFFSET));
/* check if we have enough data for polyphase filterbank */
/* it needs 1152 samples + 286 samples ignored for one granule */
/* 1152+576+286 samples for two granules */
assert(gfc->mf_size>=(286+576*(1+gfc->mode_gr)));
/* prime the MDCT/polyphase filterbank with a short block */
{
int i,j;
sample_t primebuff0[286+1152+576];
sample_t primebuff1[286+1152+576];
for (i=0, j=0; i<286+576*(1+gfc->mode_gr); ++i) {
if (i<576*gfc->mode_gr) {
primebuff0[i]=0;
if (gfc->channels_out==2)
primebuff1[i]=0;
}else{
primebuff0[i]=inbuf[0][j];
if (gfc->channels_out==2)
primebuff1[i]=inbuf[1][j];
++j;
}
}
/* polyphase filtering / mdct */
for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
for ( ch = 0; ch < gfc->channels_out; ch++ ) {
gfc->l3_side.gr[gr].ch[ch].tt.block_type=SHORT_TYPE;
}
}
mdct_sub48(gfc, primebuff0, primebuff1, xr);
}
iteration_init(gfp);
/* prepare for ATH auto adjustment:
* we want to decrease the ATH by 12 dB per second
*/ {
FLOAT8 frame_duration = 576. * gfc->mode_gr / gfp->out_samplerate;
gfc->ATH->decay = pow(10., -12./10. * frame_duration);
gfc->ATH->adjust = 1.0;
gfc->ATH->adjust_limit = 0.01;
}
}
/********************** padding *****************************/
switch (gfp->padding_type) {
case 0:
gfc->padding=0;
break;
case 1:
gfc->padding=1;
break;
case 2:
default:
if (gfp->VBR!=vbr_off) {
gfc->padding=0;
} else {
if (gfp->disable_reservoir) {
gfc->padding = 0;
/* if the user specified --nores, dont very gfc->padding either */
/* tiny changes in frac_SpF rounding will cause file differences */
}else{
/* padding method as described in
* "MPEG-Layer3 / Bitstream Syntax and Decoding"
* by Martin Sieler, Ralph Sperschneider
*
* note: there is no padding for the very first frame
*
* [email protected] 2000-06-22
*/
gfc->slot_lag -= gfc->frac_SpF;
if (gfc->slot_lag < 0) {
gfc->slot_lag += gfp->out_samplerate;
gfc->padding = 1;
} else {
gfc->padding = 0;
}
} /* reservoir enabled */
}
}
if (gfc->psymodel) {
/* psychoacoustic model
* psy model has a 1 granule (576) delay that we must compensate for
* (mt 6/99).
*/
int ret;
const sample_t *bufp[2]; /* address of beginning of left & right granule */
int blocktype[2];
ms_ratio_prev=gfc->ms_ratio[gfc->mode_gr-1];
for (gr=0; gr < gfc->mode_gr ; gr++) {
for ( ch = 0; ch < gfc->channels_out; ch++ )
bufp[ch] = &inbuf[ch][576 + gr*576-FFTOFFSET];
if (gfc->nsPsy.use) {
ret=L3psycho_anal_ns( gfp, bufp, gr,
&gfc->ms_ratio[gr],&ms_ratio_next,
masking_LR, masking_MS,
pe[gr],pe_MS[gr],tot_ener[gr],blocktype);
} else {
ret=L3psycho_anal( gfp, bufp, gr,
&gfc->ms_ratio[gr],&ms_ratio_next,
masking_LR, masking_MS,
pe[gr],pe_MS[gr],tot_ener[gr],blocktype);
}
if (ret!=0) return -4;
for ( ch = 0; ch < gfc->channels_out; ch++ )
gfc->l3_side.gr[gr].ch[ch].tt.block_type=blocktype[ch];
if (check_ms_stereo) {
ms_ener_ratio[gr] = tot_ener[gr][2]+tot_ener[gr][3];
if (ms_ener_ratio[gr]>0)
ms_ener_ratio[gr] = tot_ener[gr][3]/ms_ener_ratio[gr];
}
}
}else{
for (gr=0; gr < gfc->mode_gr ; gr++)
for ( ch = 0; ch < gfc->channels_out; ch++ ) {
gfc->l3_side.gr[gr].ch[ch].tt.block_type=NORM_TYPE;
pe_MS[gr][ch]=pe[gr][ch]=700;
}
}
/* auto-adjust of ATH, useful for low volume */
adjust_ATH( gfp, tot_ener );
/* block type flags */
for( gr = 0; gr < gfc->mode_gr; gr++ ) {
for ( ch = 0; ch < gfc->channels_out; ch++ ) {
gr_info *cod_info = &gfc->l3_side.gr[gr].ch[ch].tt;
cod_info->mixed_block_flag = 0; /* never used by this model */
if (cod_info->block_type == NORM_TYPE )
cod_info->window_switching_flag = 0;
else
cod_info->window_switching_flag = 1;
}
}
/* polyphase filtering / mdct */
mdct_sub48(gfc, inbuf[0], inbuf[1], xr);
/* re-order the short blocks, for more efficient encoding below */
for (gr = 0; gr < gfc->mode_gr; gr++) {
for (ch = 0; ch < gfc->channels_out; ch++) {
gr_info *cod_info = &gfc->l3_side.gr[gr].ch[ch].tt;
if (cod_info->block_type==SHORT_TYPE) {
freorder(gfc->scalefac_band.s,xr[gr][ch]);
}
}
}
/* use m/s gfc->channels_out? */
if (check_ms_stereo) {
int gr0 = 0, gr1 = gfc->mode_gr-1;
/* make sure block type is the same in each channel */
check_ms_stereo =
(gfc->l3_side.gr[gr0].ch[0].tt.block_type==gfc->l3_side.gr[gr0].ch[1].tt.block_type) &&
(gfc->l3_side.gr[gr1].ch[0].tt.block_type==gfc->l3_side.gr[gr1].ch[1].tt.block_type);
}
/* Here will be selected MS or LR coding of the 2 stereo channels */
assert ( gfc->mode_ext == MPG_MD_LR_LR );
gfc->mode_ext = MPG_MD_LR_LR;
if (gfp->force_ms) {
gfc->mode_ext = MPG_MD_MS_LR;
} else if (check_ms_stereo) {
/* ms_ratio = is scaled, for historical reasons, to look like
a ratio of side_channel / total.
0 = signal is 100% mono
.5 = L & R uncorrelated
*/
/* [0] and [1] are the results for the two granules in MPEG-1,
* in MPEG-2 it's only a faked averaging of the same value
* _prev is the value of the last granule of the previous frame
* _next is the value of the first granule of the next frame
*/
FLOAT8 ms_ratio_ave1;
FLOAT8 ms_ratio_ave2;
FLOAT8 threshold1 = 0.35;
FLOAT8 threshold2 = 0.45;
/* take an average */
if (gfc->mode_gr==1) {
/* MPEG2 - no second granule */
ms_ratio_ave1 = 0.33 * ( gfc->ms_ratio[0] + ms_ratio_prev + ms_ratio_next );
ms_ratio_ave2 = gfc->ms_ratio[0];
}else{
ms_ratio_ave1 = 0.25 * ( gfc->ms_ratio[0] + gfc->ms_ratio[1] + ms_ratio_prev + ms_ratio_next );
ms_ratio_ave2 = 0.50 * ( gfc->ms_ratio[0] + gfc->ms_ratio[1] );
}
if (gfp->mode_automs) {
if ( gfp->compression_ratio < 11.025 ) {
/* 11.025 => 1, 6.3 => 0 */
double thr = (gfp->compression_ratio - 6.3) / (11.025 - 6.3);
if (thr<0) thr=0;
threshold1 *= thr;
threshold2 *= thr;
}
}
if ((ms_ratio_ave1 < threshold1 && ms_ratio_ave2 < threshold2) || gfc->nsPsy.use) {
int sum_pe_MS = pe_MS[0][0] + pe_MS[0][1] + pe_MS[1][0] + pe_MS[1][1];
int sum_pe_LR = pe [0][0] + pe [0][1] + pe [1][0] + pe [1][1];
/* based on PE: M/S coding would not use much more bits than L/R coding */
if (sum_pe_MS <= 1.07 * sum_pe_LR && !gfc->nsPsy.use) gfc->mode_ext = MPG_MD_MS_LR;
if (sum_pe_MS <= 1.00 * sum_pe_LR && gfc->nsPsy.use) gfc->mode_ext = MPG_MD_MS_LR;
}
}
/* copy data for MP3 frame analyzer */
if (gfp->analysis && gfc->pinfo != NULL) {
for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
for ( ch = 0; ch < gfc->channels_out; ch++ ) {
gfc->pinfo->ms_ratio[gr]=gfc->ms_ratio[gr];
gfc->pinfo->ms_ener_ratio[gr]=ms_ener_ratio[gr];
gfc->pinfo->blocktype[gr][ch]=
gfc->l3_side.gr[gr].ch[ch].tt.block_type;
memcpy(gfc->pinfo->xr[gr][ch],xr[gr][ch],sizeof(xr[gr][ch]));
/* in psymodel, LR and MS data was stored in pinfo.
switch to MS data: */
if (gfc->mode_ext==MPG_MD_MS_LR) {
gfc->pinfo->pe[gr][ch]=gfc->pinfo->pe[gr][ch+2];
gfc->pinfo->ers[gr][ch]=gfc->pinfo->ers[gr][ch+2];
memcpy(gfc->pinfo->energy[gr][ch],gfc->pinfo->energy[gr][ch+2],
sizeof(gfc->pinfo->energy[gr][ch]));
}
}
}
}
/* bit and noise allocation */
if (MPG_MD_MS_LR == gfc->mode_ext) {
masking = &masking_MS; /* use MS masking */
pe_use = &pe_MS;
} else {
masking = &masking_LR; /* use LR masking */
pe_use = &pe;
}
if (gfc->nsPsy.use && (gfp->VBR == vbr_off || gfp->VBR == vbr_abr)) {
static FLOAT fircoef[19] = {
-0.0207887,-0.0378413,-0.0432472,-0.031183,
7.79609e-18,0.0467745,0.10091,0.151365,
0.187098,0.2,0.187098,0.151365,
0.10091,0.0467745,7.79609e-18,-0.031183,
-0.0432472,-0.0378413,-0.0207887,
};
int i;
FLOAT8 f;
for(i=0;i<18;i++) gfc->nsPsy.pefirbuf[i] = gfc->nsPsy.pefirbuf[i+1];
i=0;
gfc->nsPsy.pefirbuf[18] = 0;
for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
for ( ch = 0; ch < gfc->channels_out; ch++ ) {
gfc->nsPsy.pefirbuf[18] += (*pe_use)[gr][ch];
i++;
}
}
gfc->nsPsy.pefirbuf[18] = gfc->nsPsy.pefirbuf[18] / i;
f = 0;
for(i=0;i<19;i++) f += gfc->nsPsy.pefirbuf[i] * fircoef[i];
for ( gr = 0; gr < gfc->mode_gr; gr++ ) {
for ( ch = 0; ch < gfc->channels_out; ch++ ) {
(*pe_use)[gr][ch] *= 670 / f;
}
}
}
switch (gfp->VBR){
default:
case vbr_off:
iteration_loop( gfp,*pe_use,ms_ener_ratio, xr, *masking, l3_enc, scalefac);
break;
case vbr_mt:
VBR_quantize( gfp,*pe_use,ms_ener_ratio, xr, *masking, l3_enc, scalefac);
break;
case vbr_rh:
case vbr_mtrh:
VBR_iteration_loop( gfp,*pe_use,ms_ener_ratio, xr, *masking, l3_enc, scalefac);
break;
case vbr_abr:
ABR_iteration_loop( gfp,*pe_use,ms_ener_ratio, xr, *masking, l3_enc, scalefac);
break;
}
/* write the frame to the bitstream */
getframebits(gfp, &bitsPerFrame, &mean_bits);
format_bitstream( gfp, bitsPerFrame, l3_enc, scalefac);
/* copy mp3 bit buffer into array */
mp3count = copy_buffer(mp3buf,mp3buf_size,&gfc->bs);
if (gfp->bWriteVbrTag) AddVbrFrame(gfp);
/* copy data for MP3 frame analyzer */
if (gfp->analysis && gfc->pinfo != NULL) {
int j;
for ( ch = 0; ch < gfc->channels_out; ch++ ) {
for ( j = 0; j < FFTOFFSET; j++ )
gfc->pinfo->pcmdata[ch][j] = gfc->pinfo->pcmdata[ch][j+gfp->framesize];
for ( j = FFTOFFSET; j < 1600; j++ ) {
gfc->pinfo->pcmdata[ch][j] = inbuf[ch][j-FFTOFFSET];
}
}
set_frame_pinfo (gfp, xr, *masking, l3_enc, scalefac);
}
updateStats( gfc );
return mp3count;
}
int update_compress() {
int count = 0;
static short buffer[2][samp_per_frame];
int channel;
int i;
int gr;
short *buffer_window[2];
double win_que[2][HAN_SIZE];
double sb_sample[2][3][18][SBLIMIT];
double mdct_freq[2][2][samp_per_frame2];
int enc[2][2][samp_per_frame2];
scalefac_t scalefactor;
int mean_bits;
unsigned long sent_bits = 0;
unsigned long frame_bits = 0;
while(wave_get(buffer)) {
buffer_window[0] = buffer[0];
buffer_window[1] = buffer[1];
if(l3.frac_slots_per_frame) {
if(l3.slot_lag>(l3.frac_slots_per_frame-1.0))
{ /* No padding for this frame */
l3.slot_lag -= l3.frac_slots_per_frame;
config.mpeg.padding = 0;
}
else
{ /* Padding for this frame */
l3.slot_lag += (1-l3.frac_slots_per_frame);
config.mpeg.padding = 1;
}
}
config.mpeg.bits_per_frame = 8*(l3.whole_slots_per_frame + config.mpeg.padding);
mean_bits = (config.mpeg.bits_per_frame - l3.sideinfo_len)>>1;
/* polyphase filtering */
for(gr=0;gr<2;gr++)
for(channel=config.wave.channels; channel--; )
for(i=0;i<18;i++)
{
window_subband(&buffer_window[channel],
&win_que[channel][0],
channel);
filter_subband(&win_que[channel][0],
&sb_sample[channel][gr+1][i][0]);
}
/* apply mdct to the polyphase output */
mdct_sub(sb_sample, mdct_freq, &l3.side_info);
/* bit and noise allocation */
iteration_loop(mdct_freq,&l3.side_info,
enc, mean_bits,&scalefactor);
/* write the frame to the bitstream */
format_bitstream(enc,&l3.side_info,&scalefactor,
&l3_bs,mdct_freq);
frame_bits = sstell(&l3_bs) - sent_bits;
sent_bits += frame_bits;
count ++;
l3.frames_processed++;
if (count==30) {
return ((double)l3.frames_processed/config.mpeg.total_frames)*100;
}
}
flush_bitstream();
return 100;
//update_status(frames_processed);
}
/************************************************************************
*
* encodeframe() Layer 3
*
* encode a single frame
*
************************************************************************
lame_encode_frame()
gr 0 gr 1
inbuf: |--------------|---------------|-------------|
MDCT output: |--------------|---------------|-------------|
FFT's <---------1024---------->
<---------1024-------->
inbuf = buffer of PCM data size=MP3 framesize
encoder acts on inbuf[ch][0], but output is delayed by MDCTDELAY
so the MDCT coefficints are from inbuf[ch][-MDCTDELAY]
psy-model FFT has a 1 granule day, so we feed it data for the next granule.
FFT is centered over granule: 224+576+224
So FFT starts at: 576-224-MDCTDELAY
MPEG2: FFT ends at: BLKSIZE+576-224-MDCTDELAY
MPEG1: FFT ends at: BLKSIZE+2*576-224-MDCTDELAY (1904)
FFT starts at 576-224-MDCTDELAY (304) = 576-FFTOFFSET
*/
int lame_encode_frame(lame_global_flags *gfp,
short int inbuf_l[],short int inbuf_r[],
int mf_size,char *mp3buf, int mp3buf_size)
{
static unsigned long frameBits;
static unsigned long bitsPerSlot;
static FLOAT8 frac_SpF;
static FLOAT8 slot_lag;
static unsigned long sentBits = 0;
FLOAT8 xr[2][2][576];
int l3_enc[2][2][576];
int mp3count;
III_psy_ratio masking_ratio[2][2]; /*LR ratios */
III_psy_ratio masking_MS_ratio[2][2]; /*MS ratios */
III_psy_ratio (*masking)[2][2]; /*LR ratios and MS ratios*/
III_scalefac_t scalefac[2][2];
short int *inbuf[2];
typedef FLOAT8 pedata[2][2];
pedata pe,pe_MS;
pedata *pe_use;
int ch,gr,mean_bits;
int bitsPerFrame;
int check_ms_stereo;
static FLOAT8 ms_ratio[2]={0,0};
FLOAT8 ms_ratio_next=0;
FLOAT8 ms_ratio_prev=0;
static FLOAT8 ms_ener_ratio[2]={0,0};
memset((char *) masking_ratio, 0, sizeof(masking_ratio));
memset((char *) masking_MS_ratio, 0, sizeof(masking_MS_ratio));
memset((char *) scalefac, 0, sizeof(scalefac));
inbuf[0]=inbuf_l;
inbuf[1]=inbuf_r;
gfp->mode_ext = MPG_MD_LR_LR;
if (gfp->frameNum==0 ) {
/* Figure average number of 'slots' per frame. */
FLOAT8 avg_slots_per_frame;
FLOAT8 sampfreq = gfp->out_samplerate/1000.0;
int bit_rate = gfp->brate;
sentBits = 0;
bitsPerSlot = 8;
avg_slots_per_frame = (bit_rate*gfp->framesize) /
(sampfreq* bitsPerSlot);
/* -f fast-math option causes some strange rounding here, be carefull: */
frac_SpF = avg_slots_per_frame - floor(avg_slots_per_frame + 1e-9);
if (fabs(frac_SpF) < 1e-9) frac_SpF = 0;
slot_lag = -frac_SpF;
gfp->padding = 1;
if (frac_SpF==0) gfp->padding = 0;
/* check FFT will not use a negative starting offset */
assert(576>=FFTOFFSET);
/* check if we have enough data for FFT */
assert(mf_size>=(BLKSIZE+gfp->framesize-FFTOFFSET));
}
/********************** padding *****************************/
switch (gfp->padding_type) {
case 0:
gfp->padding=0;
break;
case 1:
gfp->padding=1;
break;
case 2:
default:
if (gfp->VBR) {
gfp->padding=0;
} else {
if (gfp->disable_reservoir) {
gfp->padding = 0;
/* if the user specified --nores, dont very gfp->padding either */
/* tiny changes in frac_SpF rounding will cause file differences */
}else{
if (frac_SpF != 0) {
if (slot_lag > (frac_SpF-1.0) ) {
slot_lag -= frac_SpF;
gfp->padding = 0;
}
else {
gfp->padding = 1;
slot_lag += (1-frac_SpF);
}
}
}
}
}
/********************** status display *****************************/
if (!gfp->gtkflag && !gfp->silent) {
int mod = gfp->version == 0 ? 200 : 50;
if (gfp->frameNum%mod==0) {
timestatus(gfp->out_samplerate,gfp->frameNum,gfp->totalframes,gfp->framesize);
#ifdef BRHIST
if (disp_brhist)
{
brhist_add_count();
brhist_disp();
}
#endif
}
}
if (gfp->psymodel) {
/* psychoacoustic model
* psy model has a 1 granule (576) delay that we must compensate for
* (mt 6/99).
*/
short int *bufp[2]; /* address of beginning of left & right granule */
int blocktype[2];
ms_ratio_prev=ms_ratio[gfp->mode_gr-1];
for (gr=0; gr < gfp->mode_gr ; gr++) {
for ( ch = 0; ch < gfp->stereo; ch++ )
bufp[ch] = &inbuf[ch][576 + gr*576-FFTOFFSET];
L3psycho_anal( gfp,bufp, gr,
&ms_ratio[gr],&ms_ratio_next,&ms_ener_ratio[gr],
masking_ratio, masking_MS_ratio,
pe[gr],pe_MS[gr],blocktype);
for ( ch = 0; ch < gfp->stereo; ch++ )
l3_side.gr[gr].ch[ch].tt.block_type=blocktype[ch];
}
}else{
for (gr=0; gr < gfp->mode_gr ; gr++)
for ( ch = 0; ch < gfp->stereo; ch++ ) {
l3_side.gr[gr].ch[ch].tt.block_type=NORM_TYPE;
pe[gr][ch]=700;
}
}
/* block type flags */
for( gr = 0; gr < gfp->mode_gr; gr++ ) {
for ( ch = 0; ch < gfp->stereo; ch++ ) {
gr_info *cod_info = &l3_side.gr[gr].ch[ch].tt;
cod_info->mixed_block_flag = 0; /* never used by this model */
if (cod_info->block_type == NORM_TYPE )
cod_info->window_switching_flag = 0;
else
cod_info->window_switching_flag = 1;
}
}
/* polyphase filtering / mdct */
mdct_sub48(gfp,inbuf[0], inbuf[1], xr, &l3_side);
/* use m/s gfp->stereo? */
check_ms_stereo = (gfp->mode == MPG_MD_JOINT_STEREO);
if (check_ms_stereo) {
/* make sure block type is the same in each channel */
check_ms_stereo =
(l3_side.gr[0].ch[0].tt.block_type==l3_side.gr[0].ch[1].tt.block_type) &&
(l3_side.gr[1].ch[0].tt.block_type==l3_side.gr[1].ch[1].tt.block_type);
}
if (check_ms_stereo) {
/* ms_ratio = is like the ratio of side_energy/total_energy */
FLOAT8 ms_ratio_ave,ms_ener_ratio_ave;
/* ms_ratio_ave = .5*(ms_ratio[0] + ms_ratio[1]);*/
ms_ratio_ave = .25*(ms_ratio[0] + ms_ratio[1]+
ms_ratio_prev + ms_ratio_next);
ms_ener_ratio_ave = .5*(ms_ener_ratio[0]+ms_ener_ratio[1]);
if ( ms_ratio_ave <.35 /*&& ms_ener_ratio_ave<.75*/ ) gfp->mode_ext = MPG_MD_MS_LR;
}
if (gfp->force_ms) gfp->mode_ext = MPG_MD_MS_LR;
#ifdef HAVEGTK
if (gfp->gtkflag) {
int j;
for ( gr = 0; gr < gfp->mode_gr; gr++ ) {
for ( ch = 0; ch < gfp->stereo; ch++ ) {
pinfo->ms_ratio[gr]=ms_ratio[gr];
pinfo->ms_ener_ratio[gr]=ms_ener_ratio[gr];
pinfo->blocktype[gr][ch]=
l3_side.gr[gr].ch[ch].tt.block_type;
for ( j = 0; j < 576; j++ ) pinfo->xr[gr][ch][j]=xr[gr][ch][j];
/* if MS stereo, switch to MS psy data */
if (gfp->mode_ext==MPG_MD_MS_LR) {
pinfo->pe[gr][ch]=pinfo->pe[gr][ch+2];
pinfo->ers[gr][ch]=pinfo->ers[gr][ch+2];
memcpy(pinfo->energy[gr][ch],pinfo->energy[gr][ch+2],
sizeof(pinfo->energy[gr][ch]));
}
}
}
}
#endif
/* bit and noise allocation */
if (MPG_MD_MS_LR == gfp->mode_ext) {
masking = &masking_MS_ratio; /* use MS masking */
pe_use=&pe_MS;
} else {
masking = &masking_ratio; /* use LR masking */
pe_use=&pe;
}
/*
VBR_iteration_loop_new( gfp,*pe_use, ms_ratio, xr, masking, &l3_side, l3_enc,
&scalefac);
*/
if (gfp->VBR) {
VBR_iteration_loop( gfp,*pe_use, ms_ratio, xr, *masking, &l3_side, l3_enc,
scalefac);
}else{
iteration_loop( gfp,*pe_use, ms_ratio, xr, *masking, &l3_side, l3_enc,
scalefac);
}
#ifdef BRHIST
brhist_temp[gfp->bitrate_index]++;
#endif
/* write the frame to the bitstream */
getframebits(gfp,&bitsPerFrame,&mean_bits);
III_format_bitstream( gfp,bitsPerFrame, l3_enc, &l3_side,
scalefac, &bs);
frameBits = bs.totbit - sentBits;
if ( frameBits % bitsPerSlot ) /* a program failure */
fprintf( stderr, "Sent %ld bits = %ld slots plus %ld\n",
frameBits, frameBits/bitsPerSlot,
frameBits%bitsPerSlot );
sentBits += frameBits;
/* copy mp3 bit buffer into array */
mp3count = copy_buffer(mp3buf,mp3buf_size,&bs);
if (gfp->bWriteVbrTag) AddVbrFrame((int)(sentBits/8));
#ifdef HAVEGTK
if (gfp->gtkflag) {
int j;
for ( ch = 0; ch < gfp->stereo; ch++ ) {
for ( j = 0; j < FFTOFFSET; j++ )
pinfo->pcmdata[ch][j] = pinfo->pcmdata[ch][j+gfp->framesize];
for ( j = FFTOFFSET; j < 1600; j++ ) {
pinfo->pcmdata[ch][j] = inbuf[ch][j-FFTOFFSET];
}
}
}
#endif
gfp->frameNum++;
return mp3count;
}
