/*

 *      time status related function source file

 *

 *      Copyright (c) 1999 Mark Taylor

 *                    2010 Robert Hegemann

 *

 * 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: timestatus.c,v 1.61 2013/03/20 20:38:43 robert Exp $ */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#if 1

# define SPEED_CHAR     "x" /* character x */

# define SPEED_MULT     1.

#else

# define SPEED_CHAR     "%%"

# define SPEED_MULT     100.

#endif

#include <assert.h>

#include <time.h>

#include <string.h>

#include <stdlib.h>

#include "lame.h"

#include "main.h"

#include "lametime.h"

#include "timestatus.h"

#include "brhist.h"

#include "console.h"

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#endif

typedef struct time_status_struct {

    double  last_time;       /* result of last call to clock */

    double  elapsed_time;    /* total time */

    double  estimated_time;  /* estimated total duration time [s] */

    double  speed_index;     /* speed relative to realtime coding [100%] */

} timestatus_t;

static struct EncoderProgress {

    timestatus_t real_time;

    timestatus_t proc_time;

    double  last_time;

    int     last_frame_num;

    int     time_status_init;

} global_encoder_progress;

/*

 *  Calculates from the input (see below) the following values:

 *    - total estimated time

 *    - a speed index

 */

static void

ts_calc_times(timestatus_t * const tstime, /* tstime->elapsed_time: elapsed time */

              const int sample_freq, /* sample frequency [Hz/kHz]  */

              const int frameNum, /* Number of the current Frame */

              const int totalframes, /* total umber of Frames */

              const int framesize)

{                       /* Size of a frame [bps/kbps] */

    assert(sample_freq >= 8000 && sample_freq <= 48000);

    if (frameNum > 0 && tstime->elapsed_time > 0) {

        tstime->estimated_time = tstime->elapsed_time * totalframes / frameNum;

        tstime->speed_index = framesize * frameNum / (sample_freq * tstime->elapsed_time);

    }

    else {

        tstime->estimated_time = 0.;

        tstime->speed_index = 0.;

    }

}

/* Decomposes a given number of seconds into a easy to read hh:mm:ss format

 * padded with an additional character

 */

static void

ts_time_decompose(const double x, const char padded_char)

{

    const unsigned long time_in_sec = (unsigned long)x;

    const unsigned long hour = time_in_sec / 3600;

    const unsigned int min = time_in_sec / 60 % 60;

    const unsigned int sec = time_in_sec % 60;

    if (hour == 0)

        console_printf("   %2u:%02u%c", min, sec, padded_char);

    else if (hour < 100)

        console_printf("%2lu:%02u:%02u%c", hour, min, sec, padded_char);

    else

        console_printf("%6lu h%c", hour, padded_char);

}

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), ' ');

}

static void

timestatus_finish(void)

{

    console_printf("\n");

}

static void

brhist_init_package(lame_global_flags const* gf)

{

    if (global_ui_config.brhist) {

        if (brhist_init(gf, lame_get_VBR_min_bitrate_kbps(gf), lame_get_VBR_max_bitrate_kbps(gf))) {

            /* fail to initialize */

            global_ui_config.brhist = 0;

        }

    }

    else {

        brhist_init(gf, 128, 128); /* Dirty hack */

    }

}

void

encoder_progress_begin( lame_global_flags const* gf

                      , char              const* inPath

                      , char              const* outPath

                      )

{

    brhist_init_package(gf);

    global_encoder_progress.time_status_init = 0;

    global_encoder_progress.last_time = 0;

    global_encoder_progress.last_frame_num = 0;

    if (global_ui_config.silent < 9) {

        char* i_file = 0;

        char* o_file = 0;

#if defined( _WIN32 ) && !defined(__MINGW32__)

        inPath = i_file = utf8ToConsole8Bit(inPath);

        outPath = o_file = utf8ToConsole8Bit(outPath);

#endif

        lame_print_config(gf); /* print useful information about options being used */

        console_printf("Encoding %s%s to %s\n",

                       strcmp(inPath, "-") ? inPath : "<stdin>",

                       strlen(inPath) + strlen(outPath) < 66 ? "" : "\n     ",

                       strcmp(outPath, "-") ? outPath : "<stdout>");

        free(i_file);

        free(o_file);

        console_printf("Encoding as %g kHz ", 1.e-3 * lame_get_out_samplerate(gf));

        {

            static const char *mode_names[2][4] = {

                {"stereo", "j-stereo", "dual-ch", "single-ch"},

                {"stereo", "force-ms", "dual-ch", "single-ch"}

            };

            switch (lame_get_VBR(gf)) {

            case vbr_rh:

                console_printf("%s MPEG-%u%s Layer III VBR(q=%g) 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" : "",

                               lame_get_VBR_quality(gf),

                               lame_get_quality(gf));

                break;

            case vbr_mt:

            case vbr_mtrh:

                console_printf("%s MPEG-%u%s Layer III VBR(q=%g)\n",

                               mode_names[lame_get_force_ms(gf)][lame_get_mode(gf)],

                               2 - lame_get_version(gf),

                               lame_get_out_samplerate(gf) < 16000 ? ".5" : "",

                               lame_get_VBR_quality(gf));

                break;

            case vbr_abr:

                console_printf("%s MPEG-%u%s Layer III (%gx) average %d kbps 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" : "",

                               0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5),

                               lame_get_VBR_mean_bitrate_kbps(gf),

                               lame_get_quality(gf));

                break;

            default:

                console_printf("%s MPEG-%u%s Layer III (%gx) %3d kbps 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" : "",

                               0.1 * (int) (10. * lame_get_compression_ratio(gf) + 0.5),

                               lame_get_brate(gf),

                               lame_get_quality(gf));

                break;

            }

        }

        if (global_ui_config.silent <= -10) {

            lame_print_internals(gf);

        }

    }

}

void

encoder_progress( lame_global_flags const* gf )

{

    if (global_ui_config.silent <= 0) {

        int const frames = lame_get_frameNum(gf);

        int const frames_diff = frames - global_encoder_progress.last_frame_num;

        if (global_ui_config.update_interval <= 0) {     /*  most likely --disptime x not used */

            if (frames_diff < 100 && frames_diff != 0) {  /*  true, most of the time */

                return;

            }

            global_encoder_progress.last_frame_num = (frames/100)*100;

        }

        else {

            if (frames != 0 && frames != 9) {

                double const act = GetRealTime();

                double const dif = act - global_encoder_progress.last_time;

                if (dif >= 0 && dif < global_ui_config.update_interval) {

                    return;

                }

            }

            global_encoder_progress.last_time = GetRealTime(); /* from now! disp_time seconds */

        }

        if (global_ui_config.brhist) {

            brhist_jump_back();

        }

        timestatus(gf);

        if (global_ui_config.brhist) {

            brhist_disp(gf);

        }

        console_flush();

    }

}

void

encoder_progress_end( lame_global_flags const* gf )

{

    if (global_ui_config.silent <= 0) {

        if (global_ui_config.brhist) {

            brhist_jump_back();

        }

        timestatus(gf);

        if (global_ui_config.brhist) {

            brhist_disp(gf);

        }

        timestatus_finish();

    }

}

/* these functions are used in get_audio.c */

static struct DecoderProgress {

    int     last_mode_ext;

    int     frames_total;

    int     frame_ctr;

    int     framesize;

    unsigned long samples;

} global_decoder_progress;

static

unsigned long calcEndPadding(unsigned long samples, int pcm_samples_per_frame)

{

    unsigned long end_padding;

    samples += 576;

    end_padding = pcm_samples_per_frame - (samples % pcm_samples_per_frame);

    if (end_padding < 576)

        end_padding += pcm_samples_per_frame;

    return end_padding;

}

static

unsigned long calcNumBlocks(unsigned long samples, int pcm_samples_per_frame)

{

    unsigned long end_padding;

    samples += 576;

    end_padding = pcm_samples_per_frame - (samples % pcm_samples_per_frame);

    if (end_padding < 576)

        end_padding += pcm_samples_per_frame;

    return (samples + end_padding) / pcm_samples_per_frame;

}

DecoderProgress

decoder_progress_init(unsigned long n, int framesize)

{

    DecoderProgress dp = &global_decoder_progress;

    dp->last_mode_ext =0;

    dp->frames_total = 0;

    dp->frame_ctr = 0;

    dp->framesize = framesize;

    dp->samples = 0;

    if (n != (0ul-1ul)) {

        if (framesize == 576 || framesize == 1152) {

            dp->frames_total = calcNumBlocks(n, framesize);

            dp->samples = 576 + calcEndPadding(n, framesize);

        }

        else if (framesize > 0) {

            dp->frames_total = n / framesize;

        }

        else {

            dp->frames_total = n;

        }

    }

    return dp;

}

static void

addSamples(DecoderProgress dp, int iread)

{

    dp->samples += iread;

    dp->frame_ctr += dp->samples / dp->framesize;

    dp->samples %= dp->framesize;

    if (dp->frames_total < dp->frame_ctr) {

        dp->frames_total = dp->frame_ctr;

    }

}

void

decoder_progress(DecoderProgress dp, const mp3data_struct * mp3data, int iread)

{

    addSamples(dp, iread);

    console_printf("\rFrame#%6i/%-6i %3i kbps",

                   dp->frame_ctr, dp->frames_total, mp3data->bitrate);

    /* Programmed with a single frame hold delay */

    /* Attention: static data */

    /* MP2 Playback is still buggy. */

    /* "'00' subbands 4-31 in intensity_stereo, bound==4" */

    /* is this really intensity_stereo or is it MS stereo? */

    if (mp3data->mode == JOINT_STEREO) {

        int     curr = mp3data->mode_ext;

        int     last = dp->last_mode_ext;

        console_printf("  %s  %c",

                       curr & 2 ? last & 2 ? " MS " : "LMSR" : last & 2 ? "LMSR" : "L  R",

                       curr & 1 ? last & 1 ? 'I' : 'i' : last & 1 ? 'i' : ' ');

        dp->last_mode_ext = curr;

    }

    else {

        console_printf("         ");

        dp->last_mode_ext = 0;

    }

/*    console_printf ("%s", Console_IO.str_clreoln ); */

    console_printf("        \b\b\b\b\b\b\b\b");

    console_flush();

}

void

decoder_progress_finish(DecoderProgress dp)

{

    (void) dp;

    console_printf("\n");

}