/*
* L3_compress:
* ------------
*/
void L3_compress(void)
{
int frames_processed;
int ch;
int i;
int gr;
static short buffer[2][1152];
short *buffer_window[2];
int remainder;
int bytes_per_frame;
int lag;
int mean_bits;
int sideinfo_len;
static int l3_enc[2][2][samp_per_frame2];
static int l3_sb_sample[2][3][18][SBLIMIT];
static int mdct_freq[2][2][samp_per_frame2];
static L3_side_info_t side_info;
if(config.mpeg.type == MPEG1)
{
config.mpeg.granules = 2;
config.mpeg.samples_per_frame = samp_per_frame;
config.mpeg.resv_limit = ((1<<9)-1)<<3;
sideinfo_len = (config.mpeg.channels == 1) ? 168 : 288;
}
else /* mpeg 2/2.5 */
{
config.mpeg.granules = 1;
config.mpeg.samples_per_frame = samp_per_frame2;
config.mpeg.resv_limit = ((1<<8)-1)<<3;
sideinfo_len = (config.mpeg.channels == 1) ? 104 : 168;
}
scalefac_band_long = sfBandIndex[config.mpeg.type][config.mpeg.samplerate_index];
#ifdef NO_RESERVOIR
config.mpeg.resv_limit = 0;
#endif
{ /* find number of whole bytes per frame and the remainder */
int x = config.mpeg.samples_per_frame * config.mpeg.bitr * (1000/8);
bytes_per_frame = x / config.wave.samplerate;
remainder = x % config.wave.samplerate;
}
config.mpeg.total_frames = /* round up */
(config.wave.total_samples + config.mpeg.samples_per_frame - 1) /
config.mpeg.samples_per_frame;
printf("%d frames\n",config.mpeg.total_frames);
frames_processed = lag = 0;
open_bit_stream(config.outfile);
while(wave_get(buffer))
{
frames_processed++;
if(((frames_processed & 7)==0) || (frames_processed >= config.mpeg.total_frames))
printf("\015[%d] %d%%", frames_processed,(frames_processed*100)/config.mpeg.total_frames);
buffer_window[0] = buffer[0];
buffer_window[1] = buffer[1];
/* sort out padding */
config.mpeg.padding = (lag += remainder) >= config.wave.samplerate;
if (config.mpeg.padding)
lag -= config.wave.samplerate;
config.mpeg.bits_per_frame = 8*(bytes_per_frame + config.mpeg.padding);
/* bits per channel per granule */
mean_bits = (config.mpeg.bits_per_frame - sideinfo_len) >>
(config.mpeg.granules + config.mpeg.channels - 2);
/* polyphase filtering */
for(gr=0; gr<config.mpeg.granules; gr++)
for(ch=0; ch<config.mpeg.channels; ch++)
for(i=0;i<18;i++)
L3_window_filter_subband(&buffer_window[ch], &l3_sb_sample[ch][gr+1][i][0] ,ch);
/* apply mdct to the polyphase output */
L3_mdct_sub(l3_sb_sample, mdct_freq);
/* bit and noise allocation */
L3_iteration_loop(mdct_freq, &side_info, l3_enc, mean_bits);
/* write the frame to the bitstream */
L3_format_bitstream(l3_enc, &side_info);
}
close_bit_stream();
}
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);
}
int main(int argc, char **argv)
{
wave_t wave;
time_t start_time, end_time;
int16_t buffer[2][samp_per_frame];
shine_config_t config;
shine_t s;
long written;
unsigned char *data;
time(&start_time);
/* Set the default MPEG encoding paramters - basically init the struct */
set_defaults(&config);
if (!parse_command(argc, argv, &config)) {
print_usage();
exit(1);
}
quiet = quiet || !strcmp(outfname, "-");
if (!quiet) print_name();
/* Open the input file and fill the config shine_wave_t header */
if (!wave_open(infname, &wave, &config, quiet))
error("Could not open WAVE file");
infile = wave.file;
/* See if samplerate is valid */
if (L3_find_samplerate_index(config.wave.samplerate) < 0) error("Unsupported samplerate");
/* See if bitrate is valid */
if (L3_find_bitrate_index(config.mpeg.bitr) < 0) error("Unsupported bitrate");
/* open the output file */
if (!strcmp(outfname, "-"))
outfile = stdout;
else
outfile = fopen(outfname, "wb");
if (!outfile) {
fprintf(stderr, "Could not create \"%s\".\n", outfname);
exit(1);
}
/* Set to stereo mode if wave data is stereo, mono otherwise. */
if (config.wave.channels > 1)
config.mpeg.mode = STEREO;
else
config.mpeg.mode = MONO;
/* Print some info about the file about to be created (optional) */
if (!quiet) check_config(&config);
/* Initiate encoder */
s = L3_initialise(&config);
/* All the magic happens here */
while (wave_get(buffer, &wave, &config)) {
data = L3_encode_frame(s, buffer, &written);
write_mp3(written, data, &config);
}
/* Flush and write remaining data. */
data = L3_flush(s, &written);
write_mp3(written, data, &config);
/* Close encoder. */
L3_close(s);
/* Close the wave file (using the wav reader) */
wave_close(&wave);
/* Close the MP3 file */
fclose(outfile);
time(&end_time);
end_time -= start_time;
if (!quiet)
printf("Finished in %02ld:%02ld:%02ld (%01.1fx realtime)\n", end_time / 3600, (end_time / 60) % 60, end_time % 60, (float)wave.duration / (float)end_time);
return 0;
}
