/*
 *	Bitrate histogram source file
 *
 *	Copyright (c) 2000 Mark Taylor
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/* $Id: brhist.c,v 1.46.2.1 2005/12/18 18:49:28 robert Exp $ */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef BRHIST

/* basic #define's */

#ifndef BRHIST_WIDTH
# define BRHIST_WIDTH    14
#endif
#ifndef BRHIST_RES
# define BRHIST_RES      14
#endif


/* #includes */

#ifdef STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
# ifndef HAVE_STRCHR
#  define strchr index
#  define strrchr rindex
# endif
char   *strchr(), *strrchr();
# ifndef HAVE_MEMCPY
#  define memcpy(d, s, n) bcopy ((s), (d), (n))
#  define memmove(d, s, n) bcopy ((s), (d), (n))
# endif
#endif


#if defined(HAVE_NCURSES_TERMCAP_H)
# include <ncurses/termcap.h>
#elif defined(HAVE_TERMCAP_H)
# include <termcap.h>
#elif defined(HAVE_TERMCAP)
# include <curses.h>
# if !defined(__bsdi__)
#  include <term.h>
# endif
#endif

#include "brhist.h"

#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif


/* Structure holding all data related to the Console I/O
 * may be this should be a more global frontend structure. So it
 * makes sense to print all files instead with
 * printf ( "blah\n") with printf ( "blah%s\n", Console_IO.str_clreoln );
 */

Console_IO_t Console_IO;

static struct {
    int     vbr_bitrate_min_index;
    int     vbr_bitrate_max_index;
    int     kbps[BRHIST_WIDTH];
    int     hist_printed_lines;
    char    bar_asterisk[512 + 1]; /* buffer filled up with a lot of '*' to print a bar     */
    char    bar_percent[512 + 1]; /* buffer filled up with a lot of '%' to print a bar     */
    char    bar_coded[512 + 1]; /* buffer filled up with a lot of ' ' to print a bar     */
    char    bar_space[512 + 1]; /* buffer filled up with a lot of ' ' to print a bar     */
} brhist;

static int
calculate_index(const int *const array, const int len, const int value)
{
    int     i;

    for (i = 0; i < len; i++)
        if (array[i] == value)
            return i;
    return -1;
}

int
brhist_init(const lame_global_flags * gf, const int bitrate_kbps_min,
            const int bitrate_kbps_max)
{
#ifdef HAVE_TERMCAP
    char    term_buff[2048]; /* see 1) */
    const char *term_name;
    char   *tp;
    char    tc[10];
    int     val;
#endif

    /* setup basics of brhist I/O channels */
    Console_IO.disp_width = 80;
    Console_IO.disp_height = 25;
    brhist.hist_printed_lines = 0;
    Console_IO.Console_fp = stderr;
    Console_IO.Error_fp = stderr;
    Console_IO.Report_fp = stderr;

    setvbuf(Console_IO.Console_fp, Console_IO.Console_buff, _IOFBF,
            sizeof(Console_IO.Console_buff));
/*  setvbuf ( Console_IO.Error_fp  , NULL                   , _IONBF, 0                                ); */

#if defined(_WIN32)  &&  !defined(__CYGWIN__)
    Console_IO.Console_Handle = GetStdHandle(STD_ERROR_HANDLE);
#endif

    strcpy(Console_IO.str_up, "\033[A");

#ifndef RH_HIST
    /* some internal checks */
    if (bitrate_kbps_min > bitrate_kbps_max) {
        fprintf(Console_IO.Error_fp,
                "lame internal error: VBR min %d kbps > VBR max %d kbps.\n",
                bitrate_kbps_min, bitrate_kbps_max);
        return -1;
    }
    if (bitrate_kbps_min < 8 || bitrate_kbps_max > 320) {
        fprintf(Console_IO.Error_fp,
                "lame internal error: VBR min %d kbps or VBR max %d kbps out of range.\n",
                bitrate_kbps_min, bitrate_kbps_max);
        return -1;
    }
#endif

    /* initialize histogramming data structure */
    lame_bitrate_kbps(gf, brhist.kbps);
    brhist.vbr_bitrate_min_index =
        calculate_index(brhist.kbps, BRHIST_WIDTH, bitrate_kbps_min);
    brhist.vbr_bitrate_max_index =
        calculate_index(brhist.kbps, BRHIST_WIDTH, bitrate_kbps_max);

    if (brhist.vbr_bitrate_min_index >= BRHIST_WIDTH ||
        brhist.vbr_bitrate_max_index >= BRHIST_WIDTH) {
        fprintf(Console_IO.Error_fp,
                "lame internal error: VBR min %d kbps or VBR max %d kbps not allowed.\n",
                bitrate_kbps_min, bitrate_kbps_max);
        return -1;
    }

    memset(brhist.bar_asterisk, '*', sizeof(brhist.bar_asterisk) - 1);
    memset(brhist.bar_percent, '%', sizeof(brhist.bar_percent) - 1);
    memset(brhist.bar_space, '-', sizeof(brhist.bar_space) - 1);
    memset(brhist.bar_coded, '-', sizeof(brhist.bar_space) - 1);

#ifdef HAVE_TERMCAP
    /* try to catch additional information about special console sequences */

    if ((term_name = getenv("TERM")) == NULL) {
        fprintf(Console_IO.Error_fp,
                "LAME: Can't get \"TERM\" environment string.\n");
        return -1;
    }
    if (tgetent(term_buff, term_name) != 1) {
        fprintf(Console_IO.Error_fp,
                "LAME: Can't find termcap entry for terminal \"%s\"\n",
                term_name);
        return -1;
    }

    val = tgetnum("co");
    if (val >= 40 && val <= 512)
        Console_IO.disp_width = val;
    val = tgetnum("li");
    if (val >= 16 && val <= 256)
        Console_IO.disp_height = val;

    *(tp = tc) = '\0';
    tp = tgetstr("up", &tp);
    if (tp != NULL)
        strcpy(Console_IO.str_up, tp);

    *(tp = tc) = '\0';
    tp = tgetstr("ce", &tp);
    if (tp != NULL)
        strcpy(Console_IO.str_clreoln, tp);

    *(tp = tc) = '\0';
    tp = tgetstr("md", &tp);
    if (tp != NULL)
        strcpy(Console_IO.str_emph, tp);

    *(tp = tc) = '\0';
    tp = tgetstr("me", &tp);
    if (tp != NULL)
        strcpy(Console_IO.str_norm, tp);

#endif /* HAVE_TERMCAP */

    return 0;
}

static int
digits(unsigned number)
{
    int     ret = 1;

    if (number >= 100000000) {
        ret += 8;
        number /= 100000000;
    }
    if (number >= 10000) {
        ret += 4;
        number /= 10000;
    }
    if (number >= 100) {
        ret += 2;
        number /= 100;
    }
    if (number >= 10) {
        ret += 1;
    }

    return ret;
}


static void
brhist_disp_line(int i, int br_hist_TOT, int br_hist_LR, int full, int frames)
{
    char    brppt[14];       /* [%] and max. 10 characters for kbps */
    int     barlen_TOT;
    int     barlen_LR;
    int     ppt = 0;
    int     res = digits(frames) + 3 + 4 + 1;

    if (full != 0) {
        /* some problems when br_hist_TOT \approx br_hist_LR: You can't see that there are still MS frames */
        barlen_TOT = (br_hist_TOT * (Console_IO.disp_width - res) + full - 1) / full; /* round up */
        barlen_LR = (br_hist_LR * (Console_IO.disp_width - res) + full - 1) / full; /* round up */
    }
    else {
        barlen_TOT = barlen_LR = 0;
    }

    if (frames > 0)
        ppt = (1000 * br_hist_TOT + frames / 2) / frames; /* round nearest */

    sprintf(brppt, " [%*i]", digits(frames), br_hist_TOT);

    if (Console_IO.str_clreoln[0]) /* ClearEndOfLine available */
        fprintf(Console_IO.Console_fp, "\n%3d%s %.*s%.*s%s",
                brhist.kbps[i], brppt,
                barlen_LR, brhist.bar_percent,
                barlen_TOT - barlen_LR, brhist.bar_asterisk,
                Console_IO.str_clreoln);
    else
        fprintf(Console_IO.Console_fp, "\n%3d%s %.*s%.*s%*s",
                brhist.kbps[i], brppt,
                barlen_LR, brhist.bar_percent,
                barlen_TOT - barlen_LR, brhist.bar_asterisk,
                Console_IO.disp_width - res - barlen_TOT, "");

    brhist.hist_printed_lines++;
}


#ifdef RH_HIST
static void
progress_line(const lame_global_flags * gf, int full, int frames)
{
    char    rst[20] = "\0";
    int     barlen_TOT = 0, barlen_COD = 0, barlen_RST = 0;
    int     res = 1;
    float   df = 0;
    unsigned int hour, min, sec;
    int     fsize = lame_get_framesize(gf);
    int     srate = lame_get_out_samplerate(gf);

    if (full < frames) {
        full = frames;
    }
    if (srate > 0) {
        df = full - frames;
        df *= fsize;
        df /= srate;
    }
    hour = df / 3600;
    df -= hour * 3600;
    min = df / 60;
    df -= min * 60;
    sec = df;
    if (full != 0) {
        if (hour > 0) {
            sprintf(rst, "%*u:%02u:%02u", digits(hour), hour, min, sec);
            res += digits(hour) + 1 + 5;
        }
        else {
            sprintf(rst, "%02u:%02u", min, sec);
            res += 5;
        }
        /* some problems when br_hist_TOT \approx br_hist_LR: You can't see that there are still MS frames */
        barlen_TOT = (full * (Console_IO.disp_width - res) + full - 1) / full; /* round up */
        barlen_COD = (frames * (Console_IO.disp_width - res) + full - 1) / full; /* round up */
        barlen_RST = barlen_TOT - barlen_COD;
        if (barlen_RST == 0) {
            sprintf(rst, "%.*s", res - 1, brhist.bar_coded);
        }
    }
    else {
        barlen_TOT = barlen_COD = barlen_RST = 0;
    }
    if (Console_IO.str_clreoln[0]) { /* ClearEndOfLine available */
        fprintf(Console_IO.Console_fp, "\n%.*s%s%.*s%s",
                barlen_COD, brhist.bar_coded,
                rst, barlen_RST, brhist.bar_space, Console_IO.str_clreoln);
    }
    else {
        fprintf(Console_IO.Console_fp, "\n%.*s%s%.*s%*s",
                barlen_COD, brhist.bar_coded,
                rst, barlen_RST, brhist.bar_space,
                Console_IO.disp_width - res - barlen_TOT, "");
    }
    brhist.hist_printed_lines++;
}


static int
stats_value(double x)
{
    if (x > 0.0) {
        fprintf(Console_IO.Console_fp, " %5.1f", x);
        return 6;
    }
    /*
       else {
       fprintf( Console_IO.Console_fp, "      " );
       return 6;
       }
     */
    return 0;
}

static int
stats_head(double x, const char *txt)
{
    if (x > 0.0) {
        fprintf(Console_IO.Console_fp, txt);
        return 6;
    }
    /*
       else {
       fprintf( Console_IO.Console_fp, "      " );
       return 6;
       }
     */
    return 0;
}


static void
stats_line(double *stat)
{
    int     n = 1;
    fprintf(Console_IO.Console_fp, "\n   kbps     ");
    n += 12;
    n += stats_head(stat[1], "  mono");
    n += stats_head(stat[2], "   IS ");
    n += stats_head(stat[3], "   LR ");
    n += stats_head(stat[4], "   MS ");
    fprintf(Console_IO.Console_fp, " %%    ");
    n += 6;
    n += stats_head(stat[5], " long ");
    n += stats_head(stat[6], "switch");
    n += stats_head(stat[7], " short");
    n += stats_head(stat[8], " mixed");
    n += fprintf(Console_IO.Console_fp, " %%");
    if (Console_IO.str_clreoln[0]) { /* ClearEndOfLine available */
        fprintf(Console_IO.Console_fp, "%s", Console_IO.str_clreoln);
    }
    else {
        fprintf(Console_IO.Console_fp, "%*s", Console_IO.disp_width - n, "");
    }
    brhist.hist_printed_lines++;

    n = 1;
    fprintf(Console_IO.Console_fp, "\n  %5.1f     ", stat[0]);
    n += 12;
    n += stats_value(stat[1]);
    n += stats_value(stat[2]);
    n += stats_value(stat[3]);
    n += stats_value(stat[4]);
    fprintf(Console_IO.Console_fp, "      ");
    n += 6;
    n += stats_value(stat[5]);
    n += stats_value(stat[6]);
    n += stats_value(stat[7]);
    n += stats_value(stat[8]);
    if (Console_IO.str_clreoln[0]) { /* ClearEndOfLine available */
        fprintf(Console_IO.Console_fp, "%s", Console_IO.str_clreoln);
    }
    else {
        fprintf(Console_IO.Console_fp, "%*s", Console_IO.disp_width - n, "");
    }
    brhist.hist_printed_lines++;
}
#endif

/* Yes, not very good */
#define LR  0
#define MS  2

void
brhist_disp(const lame_global_flags * gf)
{
    int     i, lines = 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.;
#ifdef RH_HIST
    double  stat[9] = { 0 };
    int     st_frames = 0;
#endif

    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;
    }

    for (i = 0; i < BRHIST_WIDTH; i++) {
        int     show = br_hist[i];
#ifdef RH_HIST
        show = show && (lines > 1);
#endif
        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);
    }
#ifdef RH_HIST
    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);
#endif
    fputs("\r", Console_IO.Console_fp);
    fflush(Console_IO.Console_fp); /* fflush is ALSO needed for Windows! */
}

void
brhist_jump_back(void)
{
#if defined(_WIN32)  &&  !defined(__CYGWIN__)
    if (GetFileType(Console_IO.Console_Handle) != FILE_TYPE_PIPE) {
        COORD   Pos;
        CONSOLE_SCREEN_BUFFER_INFO CSBI;

        GetConsoleScreenBufferInfo(Console_IO.Console_Handle, &CSBI);
        Pos.Y = CSBI.dwCursorPosition.Y - brhist.hist_printed_lines;
        Pos.X = 0;
        SetConsoleCursorPosition(Console_IO.Console_Handle, Pos);
    }
#else
    while (brhist.hist_printed_lines-- > 0)
        fputs(Console_IO.str_up, Console_IO.Console_fp);
#endif
}


void
brhist_disp_total(const lame_global_flags * gf)
{
#ifndef RH_HIST

    int     i;
    int     br_hist[BRHIST_WIDTH];
    int     st_mode[4];
    int     bl_type[6];
    int     st_frames = 0;
    int     br_frames = 0;
    double  sum = 0.;

    lame_stereo_mode_hist(gf, st_mode);
    lame_bitrate_hist(gf, br_hist);
    lame_block_type_hist(gf, bl_type);

    for (i = 0; i < BRHIST_WIDTH; i++) {
        br_frames += br_hist[i];
        sum += br_hist[i] * brhist.kbps[i];
    }

    for (i = 0; i < 4; i++) {
        st_frames += st_mode[i];
    }

    if (0 == br_frames)
        return;

    fprintf(Console_IO.Console_fp, "\naverage: %5.1f kbps", sum / br_frames);

    /* I'm very unhappy because this is only printed out in VBR modes */

    if (st_frames > 0) {
        if (st_mode[LR] > 0)
            fprintf(Console_IO.Console_fp, "   LR: %d (%#5.4g%%)", st_mode[LR],
                    100. * st_mode[LR] / st_frames);
        else
            fprintf(Console_IO.Console_fp, "                 ");
        if (st_mode[MS] > 0)
            fprintf(Console_IO.Console_fp, "   MS: %d (%#5.4g%%)", st_mode[MS],
                    100. * st_mode[MS] / st_frames);
    }
    fprintf(Console_IO.Console_fp, "\n");

    if (bl_type[5] > 0) {
        extern int silent;
        if (silent <= -5 && silent > -10) {
            fprintf(Console_IO.Console_fp, "block type");
            fprintf(Console_IO.Console_fp, " long: %#4.3f",
                    100. * bl_type[0] / bl_type[5]);
            fprintf(Console_IO.Console_fp, " start: %#4.3f",
                    100. * bl_type[1] / bl_type[5]);
            fprintf(Console_IO.Console_fp, " short: %#4.3f",
                    100. * bl_type[2] / bl_type[5]);
            fprintf(Console_IO.Console_fp, " stop: %#4.3f",
                    100. * bl_type[3] / bl_type[5]);
            fprintf(Console_IO.Console_fp, " mixed: %#4.3f",
                    100. * bl_type[4] / bl_type[5]);
            fprintf(Console_IO.Console_fp, " (%%)\n");
        }
        else if (silent <= -10) {
            fprintf(Console_IO.Console_fp,
                    "block types   granules   percent\n");
            fprintf(Console_IO.Console_fp, "      long: % 10d  % 8.3f%%\n",
                    bl_type[0], 100. * bl_type[0] / bl_type[5]);
            fprintf(Console_IO.Console_fp, "     start: % 10d  % 8.3f%%\n",
                    bl_type[1], 100. * bl_type[1] / bl_type[5]);
            fprintf(Console_IO.Console_fp, "     short: % 10d  % 8.3f%%\n",
                    bl_type[2], 100. * bl_type[2] / bl_type[5]);
            fprintf(Console_IO.Console_fp, "      stop: % 10d  % 8.3f%%\n",
                    bl_type[3], 100. * bl_type[3] / bl_type[5]);
            fprintf(Console_IO.Console_fp, "     mixed: % 10d  % 8.3f%%\n",
                    bl_type[4], 100. * bl_type[4] / bl_type[5]);
        }
    }
#else
    (void) gf;
#endif

    fflush(Console_IO.Console_fp);
}

/*
 * 1)
 *
 * Taken from Termcap_Manual.html:
 *
 * With the Unix version of termcap, you must allocate space for the description yourself and pass
 * the address of the space as the argument buffer. There is no way you can tell how much space is
 * needed, so the convention is to allocate a buffer 2048 characters long and assume that is
 * enough.  (Formerly the convention was to allocate 1024 characters and assume that was enough.
 * But one day, for one kind of terminal, that was not enough.)
 */

#endif /* ifdef BRHIST */