void
brhist_disp(const lame_global_flags * gf)
{
int i, lines_used = 0;
int br_hist[BRHIST_WIDTH]; /* how often a frame size was used */
int br_sm_hist[BRHIST_WIDTH][4]; /* how often a special frame size/stereo mode commbination was used */
int st_mode[4];
int bl_type[6];
int frames; /* total number of encoded frames */
int most_often; /* usage count of the most often used frame size, but not smaller than Console_IO.disp_width-BRHIST_RES (makes this sense?) and 1 */
double sum = 0.;
double stat[9] = { 0 };
int st_frames = 0;
brhist.hist_printed_lines = 0; /* printed number of lines for the brhist functionality, used to skip back the right number of lines */
lame_bitrate_stereo_mode_hist(gf, br_sm_hist);
lame_bitrate_hist(gf, br_hist);
lame_stereo_mode_hist(gf, st_mode);
lame_block_type_hist(gf, bl_type);
frames = most_often = 0;
for (i = 0; i < BRHIST_WIDTH; i++) {
frames += br_hist[i];
sum += br_hist[i] * brhist.kbps[i];
if (most_often < br_hist[i])
most_often = br_hist[i];
if (br_hist[i])
++lines_used;
}
for (i = 0; i < BRHIST_WIDTH; i++) {
int show = br_hist[i];
show = show && (lines_used > 1);
if (show || (i >= brhist.vbr_bitrate_min_index && i <= brhist.vbr_bitrate_max_index))
brhist_disp_line(i, br_hist[i], br_sm_hist[i][LR], most_often, frames);
}
for (i = 0; i < 4; i++) {
st_frames += st_mode[i];
}
if (frames > 0) {
stat[0] = sum / frames;
stat[1] = 100. * (frames - st_frames) / frames;
}
if (st_frames > 0) {
stat[2] = 0.0;
stat[3] = 100. * st_mode[LR] / st_frames;
stat[4] = 100. * st_mode[MS] / st_frames;
}
if (bl_type[5] > 0) {
stat[5] = 100. * bl_type[0] / bl_type[5];
stat[6] = 100. * (bl_type[1] + bl_type[3]) / bl_type[5];
stat[7] = 100. * bl_type[2] / bl_type[5];
stat[8] = 100. * bl_type[4] / bl_type[5];
}
progress_line(gf, lame_get_totalframes(gf), frames);
stats_line(stat);
}
void timestatus_klemm ( const lame_global_flags* const gfp )
{
static double last_time = 0.;
if ( silent <= 0 )
if ( lame_get_frameNum(gfp) == 0 ||
lame_get_frameNum(gfp) == 9 ||
GetRealTime () - last_time >= update_interval ||
GetRealTime () - last_time < 0 ) {
#ifdef BRHIST
brhist_jump_back();
#endif
timestatus ( lame_get_out_samplerate( gfp ),
lame_get_frameNum(gfp),
lame_get_totalframes(gfp),
lame_get_framesize(gfp) );
#ifdef BRHIST
if ( brhist ) {
brhist_disp ( gfp );
}
#endif
last_time = GetRealTime (); /* from now! disp_time seconds */
}
}
int
lame_encoder(lame_global_flags * gf, FILE * outf, int nogap, char *inPath,
char *outPath)
{
unsigned char mp3buffer[LAME_MAXMP3BUFFER];
int Buffer[2][1152];
int iread, imp3;
static const char *mode_names[2][4] = {
{"stereo", "j-stereo", "dual-ch", "single-ch"},
{"stereo", "force-ms", "dual-ch", "single-ch"}
};
int frames;
if (silent < 10) {
lame_print_config(gf); /* print useful information about options being used */
fprintf(stderr, "Encoding %s%s to %s\n",
strcmp(inPath, "-") ? inPath : "<stdin>",
strlen(inPath) + strlen(outPath) < 66 ? "" : "\n ",
strcmp(outPath, "-") ? outPath : "<stdout>");
fprintf(stderr,
"Encoding as %g kHz ", 1.e-3 * lame_get_out_samplerate(gf));
{
const char *appendix = "";
switch (lame_get_VBR(gf)) {
case vbr_mt:
case vbr_rh:
case vbr_mtrh:
appendix = "ca. ";
fprintf(stderr, "VBR(q=%i)", lame_get_VBR_q(gf));
break;
case vbr_abr:
fprintf(stderr, "average %d kbps",
lame_get_VBR_mean_bitrate_kbps(gf));
break;
default:
fprintf(stderr, "%3d kbps", lame_get_brate(gf));
break;
}
fprintf(stderr, " %s MPEG-%u%s Layer III (%s%gx) qval=%i\n",
mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)],
2 - lame_get_version(gf),
lame_get_out_samplerate(gf) < 16000 ? ".5" : "",
appendix,
0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5),
lame_get_quality(gf));
}
if (silent <= -10)
lame_print_internals(gf);
fflush(stderr);
}
/* encode until we hit eof */
do {
/* read in 'iread' samples */
iread = get_audio(gf, Buffer);
frames = lame_get_frameNum(gf);
/********************** status display *****************************/
if (silent <= 0) {
if (update_interval > 0) {
timestatus_klemm(gf);
}
else {
if (0 == frames % 50) {
#ifdef BRHIST
brhist_jump_back();
#endif
timestatus(lame_get_out_samplerate(gf),
frames,
lame_get_totalframes(gf),
lame_get_framesize(gf));
#ifdef BRHIST
if (brhist)
brhist_disp(gf);
#endif
}
}
}
/* encode */
imp3 = lame_encode_buffer_int(gf, Buffer[0], Buffer[1], iread,
mp3buffer, sizeof(mp3buffer));
/* was our output buffer big enough? */
if (imp3 < 0) {
if (imp3 == -1)
fprintf(stderr, "mp3 buffer is not big enough... \n");
else
fprintf(stderr, "mp3 internal error: error code=%i\n", imp3);
return 1;
}
if (fwrite(mp3buffer, 1, imp3, outf) != imp3) {
fprintf(stderr, "Error writing mp3 output \n");
return 1;
}
} while (iread);
if (nogap)
imp3 = lame_encode_flush_nogap(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
else
imp3 = lame_encode_flush(gf, mp3buffer, sizeof(mp3buffer)); /* may return one more mp3 frame */
if (imp3 < 0) {
if (imp3 == -1)
fprintf(stderr, "mp3 buffer is not big enough... \n");
else
fprintf(stderr, "mp3 internal error: error code=%i\n", imp3);
return 1;
}
if (silent <= 0) {
#ifdef BRHIST
brhist_jump_back();
#endif
frames = lame_get_frameNum(gf);
timestatus(lame_get_out_samplerate(gf),
frames, lame_get_totalframes(gf), lame_get_framesize(gf));
#ifdef BRHIST
if (brhist) {
brhist_disp(gf);
}
brhist_disp_total(gf);
#endif
timestatus_finish();
}
fwrite(mp3buffer, 1, imp3, outf);
return 0;
}
static void
timestatus(const lame_global_flags * const gfp)
{
timestatus_t* real_time = &global_encoder_progress.real_time;
timestatus_t* proc_time = &global_encoder_progress.proc_time;
int percent;
double tmx, delta;
int samp_rate = lame_get_out_samplerate(gfp)
, frameNum = lame_get_frameNum(gfp)
, totalframes = lame_get_totalframes(gfp)
, framesize = lame_get_framesize(gfp)
;
if (totalframes < frameNum) {
totalframes = frameNum;
}
if (global_encoder_progress.time_status_init == 0) {
real_time->last_time = GetRealTime();
proc_time->last_time = GetCPUTime();
real_time->elapsed_time = 0;
proc_time->elapsed_time = 0;
}
/* we need rollover protection for GetCPUTime, and maybe GetRealTime(): */
tmx = GetRealTime();
delta = tmx - real_time->last_time;
if (delta < 0)
delta = 0; /* ignore, clock has rolled over */
real_time->elapsed_time += delta;
real_time->last_time = tmx;
tmx = GetCPUTime();
delta = tmx - proc_time->last_time;
if (delta < 0)
delta = 0; /* ignore, clock has rolled over */
proc_time->elapsed_time += delta;
proc_time->last_time = tmx;
if (global_encoder_progress.time_status_init == 0) {
console_printf("\r"
" Frame | CPU time/estim | REAL time/estim | play/CPU | ETA \n"
" 0/ ( 0%%)| 0:00/ : | 0:00/ : | "
SPEED_CHAR "| : \r"
/* , Console_IO.str_clreoln, Console_IO.str_clreoln */ );
global_encoder_progress.time_status_init = 1;
return;
}
ts_calc_times(real_time, samp_rate, frameNum, totalframes, framesize);
ts_calc_times(proc_time, samp_rate, frameNum, totalframes, framesize);
if (frameNum < totalframes) {
percent = (int) (100. * frameNum / totalframes + 0.5);
}
else {
percent = 100;
}
console_printf("\r%6i/%-6i", frameNum, totalframes);
console_printf(percent < 100 ? " (%2d%%)|" : "(%3.3d%%)|", percent);
ts_time_decompose(proc_time->elapsed_time, '/');
ts_time_decompose(proc_time->estimated_time, '|');
ts_time_decompose(real_time->elapsed_time, '/');
ts_time_decompose(real_time->estimated_time, '|');
console_printf(proc_time->speed_index <= 1. ?
"%9.4f" SPEED_CHAR "|" : "%#9.5g" SPEED_CHAR "|",
SPEED_MULT * proc_time->speed_index);
ts_time_decompose((real_time->estimated_time - real_time->elapsed_time), ' ');
}
