/*

 *      GTK plotting routines source file

 *

 *      Copyright (c) 1999 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: gtkanal.c,v 1.50 2017/08/28 12:48:39 robert Exp $ */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <gtk/gtk.h>

#include "main.h"

#include "lame.h"

#include "machine.h"

#include "encoder.h"

#include "lame-analysis.h"

#include "get_audio.h"

#include "gtkanal.h"

#include "gpkplotting.h"

#include "lame_global_flags.h"

/* this file should be removed. The few data items accessed in 'gfc'

   should be made accessable by writing a lame_set_variable() function */

#include "util.h"

#include "console.h"

#ifdef _WIN32

#  include <windows.h>

#  define msleep(t) Sleep(t)

#else

#  include <unistd.h>

#  define msleep(t) usleep((t) * 1000)

#endif

/*! Stringify \a x. */

#define STR(x)   #x

/*! Stringify \a x, perform macro expansion. */

#define XSTR(x)  STR(x)

#define MP3X_MAJOR_VERSION      0 /* Major version number */

#define MP3X_MINOR_VERSION     82 /* Minor version number */

#define MP3X_ALPHA_VERSION      0 /* Set number if this is an alpha version, otherwise zero */

#define MP3X_BETA_VERSION       0 /* Set number if this is a beta version, otherwise zero */

plotting_data *pinfo;

plotting_data *pplot;

plotting_data Pinfo[NUMPINFO];

/* global variables for the state of the system */

static gint idle_keepgoing;  /* processing of frames is ON */

static gint idle_count_max;  /* number of frames to process before plotting */

static gint idle_count;      /* pause & plot when idle_count=idel_count_max */

static gint idle_end = 0;    /* process all frames, stop at last frame  */

static gint idle_back = 0;   /* set when we are displaying the old data */

static int mp3done = 0;      /* last frame has been read */

static GtkWidget *frameprogress; /* progress bar */

static GtkWidget *framecounter; /* progress counter */

static int subblock_draw[3] = { 1, 1, 1 };

/* main window */

GtkWidget *window;

/* Backing pixmap for drawing areas */

GtkWidget *pcmbox;           /* PCM data plotted here */

GtkWidget *winbox;           /* mpg123 synthesis data plotted here */

GtkWidget *enerbox[2];       /* spectrum, gr=0,1 plotted here */

GtkWidget *mdctbox[2];       /* mdct coefficients gr=0,1 plotted here */

GtkWidget *sfbbox[2];        /* scalefactors gr=0,1 plotted here */

GtkWidget *headerbox;        /* mpg123 header info shown here */

struct gtkinfostruct {

    int     filetype;        /* input file type 0=WAV, 1=MP3 */

    int     msflag;          /* toggle between L&R vs M&S PCM data display */

    int     chflag;          /* toggle between L & R channels */

    int     kbflag;          /* toggle between wave # and barks */

    int     flag123;         /* show mpg123 frame info, OR ISO encoder frame info */

    double  avebits;         /* running average bits per frame */

    int     approxbits;      /* (approx) bits per frame */

    int     maxbits;         /* max bits per frame used so far */

    int     totemph;         /* total of frames with de-emphasis */

    int     totms;           /* total frames with ms_stereo */

    int     totis;           /* total frames with i_stereo */

    int     totshort;        /* total granules with short blocks */

    int     totmix;          /* total granules with mixed blocks */

    int     totpreflag;      /* total granules with preflag */

    int     pupdate;         /* plot while processing, or only when needed */

    int     sfblines;        /* plot scalefactor bands in MDCT plot */

    int     difference;      /* plot original - decoded instead of orig vs. decoded */

    int     totalframes;

} gtkinfo;

static lame_global_flags *gfp;

lame_internal_flags *gfc;

hip_t hip; /* decoder handle of just encoded data */

/**********************************************************************

 * read one frame and encode it

 **********************************************************************/

int

gtkmakeframe(void)

{

    int     iread = 0;

    static int init = 0;

    static int mpglag;

    static short int Buffer[2][1152];

    short int mpg123pcm[2][1152];

    int     ch, j;

    int     mp3count = 0;

    int     mp3out = 0;

    int     channels_out;

    unsigned char mp3buffer[LAME_MAXMP3BUFFER];

    static int frameNum = 0;

    int     framesize = lame_get_framesize(gfp);

    channels_out = (lame_get_mode(gfp) == MONO) ? 1 : 2;

    pinfo->frameNum = frameNum;

    pinfo->sampfreq = lame_get_out_samplerate(gfp);

    pinfo->framesize = framesize;

    pinfo->stereo = channels_out;

    /* If the analsys code is enabled, lame will writes data into gfc->pinfo,

     * and mpg123 will write data into pinfo.  Set these so

     * the libraries put this data in the right place: */

    gfc->pinfo = pinfo;

    hip_set_pinfo(hip, pinfo);

    if (is_mpeg_file_format(global_reader.input_format)) {

        hip_set_pinfo(get_hip(), pplot);

        iread = get_audio16(gfp, Buffer);

        /* add a delay of framesize-DECDELAY, which will make the total delay

         * exactly one frame, so we can sync MP3 output with WAV input */

        for (ch = 0; ch < channels_out; ch++) {

            for (j = 0; j < framesize - DECDELAY; j++)

                pinfo->pcmdata2[ch][j] = pinfo->pcmdata2[ch][j + framesize];

            for (j = 0; j < framesize; j++) /*rescale from int to short int */

                pinfo->pcmdata2[ch][j + framesize - DECDELAY] = Buffer[ch][j];

        }

        pinfo->frameNum123 = frameNum - 1;

        ++frameNum;

    }

    else {

        /* feed data to encoder until encoder produces some output */

        while (lame_get_frameNum(gfp) == pinfo->frameNum) {

            if (!init) {

                init = 1;

                mpglag = 1;

                if (hip) {

                    hip_decode_exit(hip);

                }

                hip = hip_decode_init();

                hip_set_pinfo(hip, pinfo);

            }

            iread = get_audio16(gfp, Buffer);

            if (iread > framesize) {

                /* NOTE: frame analyzer requires that we encode one frame

                 * for each pass through this loop.  If lame_encode_buffer()

                 * is feed data too quickly, it will sometimes encode multiple frames

                 * breaking this loop.

                 */

                error_printf("Warning: get_audio is returning too much data.\n");

            }

            if (iread <= 0)

                break;  /* eof */

            mp3count = lame_encode_buffer(gfp, Buffer[0], Buffer[1], iread,

                                          mp3buffer, sizeof(mp3buffer));

            assert(!(mp3count > 0 && lame_get_frameNum(gfp) == pinfo->frameNum));

            /* not possible to produce mp3 data without encoding at least

             * one frame of data which would increment frameNum */

        }

        frameNum = lame_get_frameNum(gfp); /* use the internal MP3 frame counter */

        /* decode one frame of output */

        mp3out = hip_decode1(hip, mp3buffer, mp3count, mpg123pcm[0], mpg123pcm[1]); /* re-synthesis to pcm */

        /* mp3out = 0:  need more data to decode */

        /* mp3out = -1:  error.  Lets assume 0 pcm output */

        /* mp3out = number of samples output */

        if (mp3out > 0)

            assert(mp3out == pinfo->framesize);

        if (mp3out != 0) {

            /* decoded output is for frame pinfo->frameNum123

             * add a delay of framesize-DECDELAY, which will make the total delay

             * exactly one frame */

            pinfo->frameNum123 = pinfo->frameNum - mpglag;

            for (ch = 0; ch < pinfo->stereo; ch++) {

                for (j = 0; j < pinfo->framesize - DECDELAY; j++)

                    pinfo->pcmdata2[ch][j] = pinfo->pcmdata2[ch][j + pinfo->framesize];

                for (j = 0; j < pinfo->framesize; j++) {

                    pinfo->pcmdata2[ch][j + pinfo->framesize - DECDELAY] =

                        (mp3out == -1) ? 0 : mpg123pcm[ch][j];

                }

            }

        }

        else {

            if (mpglag == MAXMPGLAG) {

                error_printf("READ_AHEAD set too low - not enough frame buffering.\n"

                             "MP3x display of input and output PCM data out of sync.\n");

                error_flush();

            }

            else

                mpglag++;

            pinfo->frameNum123 = -1; /* no frame output */

        }

    }

    return iread;

}

void

plot_frame(void)

{

    int     i, j, n, ch, gr;

    gdouble *xcord, *ycord;

    gdouble xmx, xmn, ymx, ymn;

    double *data, *data2, *data3;

    char    title2[80];

    char    label[80], label2[80];

    char   *title;

    plotting_data *pplot1;

    plotting_data *pplot2 = NULL;

    double  en, samp;

    /*int     sampindex, version = 0;*/

    int     barthick;

    static int firstcall = 1;

    static GdkColor *barcolor, *color, *grcolor[2];

    static GdkColor yellow, gray, cyan, magenta, orange, pink, red, green, blue, black, oncolor,

        offcolor;

    int     blocktype[2][2];

    int     headbits;

    int     mode_gr = 2;

    /* find the frame where mpg123 produced output coming from input frame

     * pinfo.  i.e.:   out_frame + out_frame_lag = input_frame  */

    for (i = 1; i <= MAXMPGLAG; i++) {

        if ((pplot - i)->frameNum123 == pplot->frameNum) {

            pplot2 = pplot - i;

            break;

        }

    }

    if (i > MAXMPGLAG) {

        error_printf("input/output pcm syncing problem.  should not happen!\n");

        pplot2 = pplot - 1;

    }

    /* however, the PCM data is delayed by 528 samples in the encoder filterbanks.

     * We added another 1152-528 delay to this so the PCM data is *exactly* one

     * frame behind the header & MDCT information */

    pplot1 = pplot2 + 1; /* back one frame for header info, MDCT */

    /* allocate these GC's only once */

    if (firstcall) {

        firstcall = 0;

        /*    grcolor[0] = &magenta; */

        grcolor[0] = &blu;;

        grcolor[1] = &green;

        barcolor = &gray;

        setcolor(headerbox, &oncolor, 255, 0, 0);

        setcolor(headerbox, &offcolor, 175, 175, 175);

        setcolor(pcmbox, &red, 255, 0, 0);

        setcolor(pcmbox, &pink, 255, 0, 255);

        setcolor(pcmbox, &magenta, 255, 0, 100);

        setcolor(pcmbox, &orange, 255, 127, 0);

        setcolor(pcmbox, &cyan, 0, 255, 255);

        setcolor(pcmbox, &green, 0, 255, 0);

        setcolor(pcmbox, &blue, 0, 0, 255);

        setcolor(pcmbox, &black, 0, 0, 0);

        setcolor(pcmbox, &gray, 100, 100, 100);

        setcolor(pcmbox, &yellow, 255, 255, 0);

    }

  /*******************************************************************

   * frame header info

   *******************************************************************/

    if (pplot1->sampfreq)

        samp = pplot1->sampfreq;

    else

        samp = 1;

    /*sampindex = SmpFrqIndex((long) samp, &version);*/

    ch = gtkinfo.chflag;

    headbits = 32 + ((pplot1->stereo == 2) ? 256 : 136);

    gtkinfo.approxbits = (pplot1->bitrate * 1000 * 1152.0 / samp) - headbits;

    sprintf(title2, "%3.1fkHz %ikbs ", samp / 1000, pplot1->bitrate);

    gtk_text_freeze(GTK_TEXT(headerbox));

    gtk_text_backward_delete(GTK_TEXT(headerbox), gtk_text_get_length(GTK_TEXT(headerbox)));

    gtk_text_set_point(GTK_TEXT(headerbox), 0);

    gtk_text_insert(GTK_TEXT(headerbox), NULL, &oncolor, NULL, title2, -1);

    title = " mono ";

    if (2 == pplot1->stereo)

        title = pplot1->js ? " js " : " s ";

    gtk_text_insert(GTK_TEXT(headerbox), NULL, &oncolor, NULL, title, -1);

    color = pplot1->ms_stereo ? &oncolor : &offcolor;

    gtk_text_insert(GTK_TEXT(headerbox), NULL, color, NULL, "ms ", -1);

    color = pplot1->i_stereo ? &oncolor : &offcolor;

    gtk_text_insert(GTK_TEXT(headerbox), NULL, color, NULL, "is ", -1);

    color = pplot1->crc ? &oncolor : &offcolor;

    gtk_text_insert(GTK_TEXT(headerbox), NULL, color, NULL, "crc ", -1);

    color = pplot1->padding ? &oncolor : &offcolor;

    gtk_text_insert(GTK_TEXT(headerbox), NULL, color, NULL, "pad ", -1);

    color = pplot1->emph ? &oncolor : &offcolor;

    gtk_text_insert(GTK_TEXT(headerbox), NULL, color, NULL, "em ", -1);

    sprintf(title2, "bv=%i,%i ", pplot1->big_values[0][ch], pplot1->big_values[1][ch]);

    gtk_text_insert(GTK_TEXT(headerbox), NULL, &black, NULL, title2, -1);

    color = pplot1->scfsi[ch] ? &oncolor : &offcolor;

    sprintf(title2, "scfsi=%i            ", pplot1->scfsi[ch]);

    gtk_text_insert(GTK_TEXT(headerbox), NULL, color, NULL, title2, -1);

    if (gtkinfo.filetype)

        sprintf(title2, " mdb=%i %i/NA", pplot1->maindata, pplot1->totbits);

    else

        sprintf(title2, " mdb=%i   %i/%i",

                pplot1->maindata, pplot1->totbits, pplot1->totbits + pplot->resvsize);

    gtk_text_insert(GTK_TEXT(headerbox), NULL, &oncolor, NULL, title2, -1);

    gtk_text_thaw(GTK_TEXT(headerbox));

  /*******************************************************************

   * block type

   *******************************************************************/

    for (gr = 0; gr < mode_gr; gr++)

        if (gtkinfo.flag123)

            blocktype[gr][ch] = pplot1->mpg123blocktype[gr][ch];

        else

            blocktype[gr][ch] = pplot->blocktype[gr][ch];

  /*******************************************************************

   * draw the PCM data *

   *******************************************************************/

    n = 1600;           /* PCM frame + FFT window:   224 + 1152 + 224  */

    xcord = g_malloc(n * sizeof(gdouble));

    ycord = g_malloc(n * sizeof(gdouble));

    if (gtkinfo.msflag)

        title = ch ? "Side Channel" : "Mid Channel";

    else

        title = ch ? "Right Channel" : "Left Channel";

    sprintf(title2, "%s  mask_ratio=%3.2f  %3.2f  ener_ratio=%3.2f  %3.2f",

            title,

            pplot->ms_ratio[0], pplot->ms_ratio[1],

            pplot->ms_ener_ratio[0], pplot->ms_ener_ratio[1]);

    ymn = -32767;

    ymx = 32767;

    xmn = 0;

    xmx = 1600 - 1;

    /*  0  ... 224      draw in black, connecting to 224 pixel

     * 1375 .. 1599     draw in black  connecting to 1375 pixel

     * 224 ... 1375     MP3 frame.  draw in blue

     */

    /* draw the title */

    gpk_graph_draw(pcmbox, 0, xcord, ycord, xmn, ymn, xmx, ymx, 1, title2, &black);

    /* draw some hash marks dividing the frames */

    ycord[0] = ymx * .8;

    ycord[1] = ymn * .8;

    for (gr = 0; gr <= 2; gr++) {

        xcord[0] = 223.5 + gr * 576;

        xcord[1] = 223.5 + gr * 576;

        gpk_rectangle_draw(pcmbox, xcord, ycord, xmn, ymn, xmx, ymx, &yellow);

    }

    for (gr = 0; gr < mode_gr; gr++) {

        if (blocktype[gr][ch] == 2)

            for (i = 1; i <= 2; i++) {

                xcord[0] = 223.5 + gr * 576 + i * 192;

                xcord[1] = 223.5 + gr * 576 + i * 192;

                gpk_rectangle_draw(pcmbox, xcord, ycord, xmn, ymn, xmx, ymx, &yellow);

            }

    }

    /* bars representing FFT windows */

    xcord[0] = 0;

    ycord[0] = ymn + 3000;

    xcord[1] = 1024 - 1;

    ycord[1] = ymn + 1000;

    gpk_rectangle_draw(pcmbox, xcord, ycord, xmn, ymn, xmx, ymx, grcolor[0]);

    xcord[0] = 576;

    ycord[0] = ymn + 2000;

    xcord[1] = 576 + 1024 - 1;

    ycord[1] = ymn;

    gpk_rectangle_draw(pcmbox, xcord, ycord, xmn, ymn, xmx, ymx, grcolor[1]);

    /* plot PCM data */

    for (i = 0; i < n; i++) {

        xcord[i] = i;

        if (gtkinfo.msflag)

            ycord[i] = ch ? .5 * (pplot->pcmdata[0][i] - pplot->pcmdata[1][i]) :

                .5 * (pplot->pcmdata[0][i] + pplot->pcmdata[1][i]);

        else

            ycord[i] = pplot->pcmdata[ch][i];

    }

    /* skip plot if we are doing an mp3 file */

    if (!gtkinfo.filetype) {

        gpk_graph_draw(pcmbox, n, xcord, ycord, xmn, ymn, xmx, ymx, 0, title2, &black);

    }

  /*******************************************************************/

    /* draw the PCM re-synthesis data */

  /*******************************************************************/

    n = 1152;

    /*

       sprintf(title2,"Re-synthesis  mask_ratio=%3.2f  %3.2f  ener_ratio=%3.2f  %3.2f",

       pplot->ms_ratio[0],pplot->ms_ratio[1],

       pplot->ms_ener_ratio[0],pplot->ms_ener_ratio[1]);

     */

    title = "Re-synthesis";

    if (gtkinfo.difference)

        title = "Re-synthesis difference (amplified 20db)";

    ymn = -32767;

    ymx = 32767;

    xmn = 0;

    xmx = 1600 - 1;

    gpk_graph_draw(winbox, 0, xcord, ycord, xmn, ymn, xmx, ymx, 1, title, &black);

    /* draw some hash marks dividing the frames */

    ycord[0] = ymx * .8;

    ycord[1] = ymn * .8;

    for (gr = 0; gr <= 2; gr++) {

        xcord[0] = 223.5 + gr * 576;

        xcord[1] = 223.5 + gr * 576;

        gpk_rectangle_draw(winbox, xcord, ycord, xmn, ymn, xmx, ymx, &yellow);

    }

    for (gr = 0; gr < 2; gr++) {

        if (blocktype[gr][ch] == 2)

            for (i = 1; i <= 2; i++) {

                xcord[0] = 223.5 + gr * 576 + i * 192;

                xcord[1] = 223.5 + gr * 576 + i * 192;

                gpk_rectangle_draw(winbox, xcord, ycord, xmn, ymn, xmx, ymx, &yellow);

            }

    }

    /* this piece of PCM data from previous frame */

    n = 224;

    for (j = 1152 - n, i = 0; i < n; i++, j++) {

        xcord[i] = i;

        if (gtkinfo.msflag)

            ycord[i] = ch ? .5 * (pplot1->pcmdata2[0][j] -

                                  pplot1->pcmdata2[1][j]) :

                .5 * (pplot1->pcmdata2[0][j] + pplot1->pcmdata2[1][j]);

        else

            ycord[i] = pplot1->pcmdata2[ch][j];

    }

    /* this piece of PCM data from current frame */

    n = 1152;

    for (i = 0; i < n; i++) {

        xcord[i + 224] = i + 224;

        if (gtkinfo.msflag)

            ycord[i + 224] = ch ? .5 * (pplot2->pcmdata2[0][i] - pplot2->pcmdata2[1][i]) :

                .5 * (pplot2->pcmdata2[0][i] + pplot2->pcmdata2[1][i]);

        else

            ycord[i + 224] = pplot2->pcmdata2[ch][i];

    }

    n = 1152 + 224;

    if (gtkinfo.difference) {

        for (i = 0; i < n; i++) {

            if (gtkinfo.msflag)

                ycord[i] -= ch ? .5 * (pplot->pcmdata[0][i] - pplot->pcmdata[1][i]) :

                    .5 * (pplot->pcmdata[0][i] + pplot->pcmdata[1][i]);

            else

                ycord[i] -= pplot->pcmdata[ch][i];

        }

        ycord[i] *= 100;

    }

    gpk_graph_draw(winbox, n, xcord, ycord, xmn, ymn, xmx, ymx, 0, title, &black);

  /*******************************************************************/

    /* draw the MDCT energy spectrum */

  /*******************************************************************/

    for (gr = 0; gr < mode_gr; gr++) {

        int     bits, bits2;

        char   *blockname = "";

        switch (blocktype[gr][ch]) {

        case 0:

            blockname = "normal";

            break;

        case 1:

            blockname = "start";

            break;

        case 2:

            blockname = "short";

            break;

        case 3:

            blockname = "end";

            break;

        }

        strcpy(label, blockname);

        if (pplot1->mixed[gr][ch])

            strcat(label, "(mixed)");

        n = 576;

        if (gtkinfo.flag123) {

            data = pplot1->mpg123xr[gr][0];

            data2 = pplot1->mpg123xr[gr][1];

        }

        else {

            data = pplot->xr[gr][0];

            data2 = pplot->xr[gr][1];

        }

        xmn = 0;

        xmx = n - 1;

        ymn = 0;

        ymx = 11;

        /* draw title, erase old plot */

        if (gtkinfo.flag123) {

            bits = pplot1->mainbits[gr][ch];

            bits2 = pplot1->sfbits[gr][ch];

        }

        else {

            bits = pplot->LAMEmainbits[gr][ch];

            bits2 = pplot->LAMEsfbits[gr][ch];

        }

        sprintf(title2, "MDCT%1i(%s) bits=%i/%i ", gr, label, bits, bits2);

        gpk_bargraph_draw(mdctbox[gr], 0, xcord, ycord, xmn, ymn, xmx, ymx, 1, title2, 0, barcolor);

        /* draw some hash marks showing scalefactor bands */

        if (gtkinfo.sfblines) {

            int     fac, nsfb, *scalefac;

            if (blocktype[gr][ch] == SHORT_TYPE) {

                nsfb = SBMAX_s;

                i = nsfb - 7;

                fac = 3;

                scalefac = gfc->scalefac_band.s;

            }

            else {

                nsfb = SBMAX_l;

                i = nsfb - 10;

                fac = 1;

                scalefac = gfc->scalefac_band.l;

            }

            for (; i < nsfb; i++) {

                ycord[0] = .8 * ymx;

                ycord[1] = ymn;

                xcord[0] = fac * scalefac[i];

                xcord[1] = xcord[0];

                gpk_rectangle_draw(mdctbox[gr], xcord, ycord, xmn, ymn, xmx, ymx, &yellow);

            }

        }

        ymn = 9e20;

        ymx = -9e20;

        for (i = 0; i < n; i++) {

            double  coeff;

            xcord[i] = i;

            if (gtkinfo.msflag) {

                coeff = ch ? .5 * (data[i] - data2[i]) : .5 * (data[i] + data2[i]);

            }

            else {

                coeff = ch ? data2[i] : data[i];

            }

            if (blocktype[gr][ch] == SHORT_TYPE && !subblock_draw[i % 3])

                coeff = 0;

            ycord[i] = coeff * coeff * 1e10;

            ycord[i] = log10(MAX(ycord[i], (double) 1));

#if 0

            if (ch == 0)

                if (i == 26)

                    if (data[i] != 0)

                        console_printf("%i %i i=%i  mdct: (db) %f  %f \n", pplot->frameNum, gr, i,

                                       10 * log10(data[i] * data[i]),

                                       10 * log10(.33 *

                                                  (data[i - 1] * data[i - 1] + data[i] * data[i] +

                                                   data[i + 1] * data[i + 1]))

                            );

#endif

            ymx = (ycord[i] > ymx) ? ycord[i] : ymx;

            ymn = (ycord[i] < ymn) ? ycord[i] : ymn;

        }

        /*  print the min/max

           sprintf(title2,"MDCT%1i %5.2f %5.2f  bits=%i",gr,ymn,ymx,

           pplot1->mainbits[gr][ch]);

         */

        if (gtkinfo.flag123)

            bits = pplot1->mainbits[gr][ch];

        else

            bits = pplot->LAMEmainbits[gr][ch];

        sprintf(title2, "MDCT%1i(%s) bits=%i ", gr, label, bits);

        xmn = 0;

        xmx = n - 1;

        ymn = 0;

        ymx = 11;

        gpk_bargraph_draw(mdctbox[gr], n, xcord, ycord, xmn, ymn, xmx, ymx, 0, title2, 0, barcolor);

    }

  /*******************************************************************

   * draw the psy model energy spectrum (k space)

   * l3psy.c computes pe, en, thm for THIS granule.

   *******************************************************************/

    if (gtkinfo.kbflag) {

        for (gr = 0; gr < mode_gr; gr++) {

            n = HBLKSIZE; /* only show half the spectrum */

            data = &pplot->energy[gr][ch][0];

            ymn = 9e20;

            ymx = -9e20;

            for (i = 0; i < n; i++) {

                xcord[i] = i + 1;

                if (blocktype[gr][ch] == SHORT_TYPE && !subblock_draw[i % 3])

                    ycord[i] = 0;

                else

                    ycord[i] = log10(MAX(data[i], (double) 1));

                ymx = (ycord[i] > ymx) ? ycord[i] : ymx;

                ymn = (ycord[i] < ymn) ? ycord[i] : ymn;

            }

            for (en = 0, j = 0; j < BLKSIZE; j++)

                en += pplot->energy[gr][ch][j];

            sprintf(title2, "FFT%1i  pe=%5.2fK  en=%5.2e ", gr, pplot->pe[gr][ch] / 1000, en);

            ymn = 3;

            ymx = 15;

            xmn = 1;

            xmx = n;

            gpk_bargraph_draw(enerbox[gr], n, xcord, ycord,

                              xmn, ymn, xmx, ymx, 1, title2, 0, barcolor);

        }

    }

    else {

    /*******************************************************************

     * draw the psy model energy spectrum (scalefactor bands)

     *******************************************************************/

        for (gr = 0; gr < mode_gr; gr++) {

            if (blocktype[gr][ch] == 2) {

                n = 3 * SBMAX_s;

                data = &pplot->en_s[gr][ch][0];

                data2 = &pplot->thr_s[gr][ch][0];

                data3 = &pplot->xfsf_s[gr][ch][0];

            }

            else {

                n = SBMAX_l;

                data = &pplot->en[gr][ch][0];

                data2 = &pplot->thr[gr][ch][0];

                data3 = &pplot->xfsf[gr][ch][0];

            }

            ymn = 9e20;

            ymx = -9e20;

            for (i = 0; i < n; i++) {

                xcord[i] = i + 1;

                if (blocktype[gr][ch] == SHORT_TYPE && !subblock_draw[i % 3])

                    ycord[i] = 0;

                else

                    ycord[i] = log10(MAX(data[i], (double) 1));

                /*

                   ymx=(ycord[i] > ymx) ? ycord[i] : ymx;

                   ymn=(ycord[i] < ymn) ? ycord[i] : ymn;

                 */

            }

            /* en = max energy difference amoung the 3 short FFTs for this granule */

            en = pplot->ers[gr][ch];

            if (en > 999)

                en = 999;

            sprintf(title2,

                    "FFT%1i pe=%5.2fK/%3.1f \nnoise ovr_b:%i/max:%3.1f/ovr:%3.1f/tot:%3.1f/ssd:%i",

                    gr, pplot->pe[gr][ch] / 1000, en, pplot->over[gr][ch], pplot->max_noise[gr][ch],

                    pplot->over_noise[gr][ch], pplot->tot_noise[gr][ch], pplot->over_SSD[gr][ch]);

            barthick = 3;

            if (blocktype[gr][ch] == SHORT_TYPE)

                barthick = 2;

            if (!(subblock_draw[0] && subblock_draw[1] && subblock_draw[2]))

                barthick = 3;

            ymn = 3;

            ymx = 15;

            xmn = 1;

            xmx = n + 1; /* a little extra because of the bar thickness */

            gpk_bargraph_draw(enerbox[gr], n, xcord, ycord,

                              xmn, ymn, xmx, ymx, 1, title2, barthick, barcolor);

            for (i = 0; i < n; i++) {

                xcord[i] = i + 1 + .20;

                if (blocktype[gr][ch] == SHORT_TYPE && !subblock_draw[i % 3])

                    ycord[i] = 0;

                else

                    ycord[i] = log10(MAX(data2[i], (double) 1));

            }

            gpk_bargraph_draw(enerbox[gr], n, xcord, ycord,

                              xmn, ymn, xmx, ymx, 0, title2, barthick, grcolor[gr]);

            for (i = 0; i < n; i++) {

                xcord[i] = i + 1 + .40;

                if (blocktype[gr][ch] == SHORT_TYPE && !subblock_draw[i % 3])

                    ycord[i] = 0;

                else

                    ycord[i] = log10(MAX(data3[i], (double) 1));

            }

            gpk_bargraph_draw(enerbox[gr], n, xcord, ycord,

                              xmn, ymn, xmx, ymx, 0, title2, barthick, &red;;

        }

    }

  /*******************************************************************

   * draw scalefactors

   *******************************************************************/

    for (gr = 0; gr < mode_gr; gr++) {

        int     ggain;

        if (blocktype[gr][ch] == 2) {

            n = 3 * SBMAX_s;

            if (gtkinfo.flag123)

                data = pplot1->sfb_s[gr][ch];

            else

                data = pplot->LAMEsfb_s[gr][ch];

        }

        else {

            n = SBMAX_l;

            if (gtkinfo.flag123)

                data = pplot1->sfb[gr][ch];

            else

                data = pplot->LAMEsfb[gr][ch];

        }

        ymn = -1;

        ymx = 10;

        for (i = 0; i < n; i++) {

            xcord[i] = i + 1;

            if (blocktype[gr][ch] == SHORT_TYPE && !subblock_draw[i % 3])

                ycord[i] = 0;

            else

                ycord[i] = -data[i];

            ymx = (ycord[i] > ymx - 2) ? ycord[i] + 2 : ymx;

            ymn = (ycord[i] < ymn) ? ycord[i] - 1 : ymn;

        }

        if (blocktype[gr][ch] == 2) {

            sprintf(label2,

                    "SFB scale=%i preflag=%i  %i%i%i",

                    pplot1->scalefac_scale[gr][ch],

                    pplot1->preflag[gr][ch],

                    pplot1->sub_gain[gr][ch][0],

                    pplot1->sub_gain[gr][ch][1], pplot1->sub_gain[gr][ch][2]);

        }

        else {

            sprintf(label2, "SFB scale=%i preflag=%i", pplot1->scalefac_scale[gr][ch],

                    pplot1->preflag[gr][ch]);

        }

        if (gtkinfo.flag123)

            ggain = (pplot1->qss[gr][ch]);

        else

            ggain = (pplot->LAMEqss[gr][ch]);

        sprintf(title2, " ggain=%i", ggain);

        strcat(label2, title2);

        xmn = 1;

        xmx = n + 1;

        gpk_bargraph_draw(sfbbox[gr], n, xcord, ycord,

                          xmn, ymn, xmx, ymx, 1, label2, 0, grcolor[gr]);

        ycord[0] = ycord[1] = 0;

        xcord[0] = 1;

        xcord[1] = n + 1;

        gpk_rectangle_draw(sfbbox[gr], xcord, ycord, xmn, ymn, xmx, ymx, &yellow);

    }

}

static void

update_progress(void)

{

    char    label[80];

    int     tf = lame_get_totalframes(gfp);

    if (gtkinfo.totalframes > 0)

        tf = gtkinfo.totalframes;

    sprintf(label, "Frame:%4i/%4i  %6.2fs", pplot->frameNum, (int) tf - 1, pplot->frametime);

    gtk_progress_set_value(GTK_PROGRESS(frameprogress), (gdouble) pplot->frameNum);

    gtk_label_set_text(GTK_LABEL(framecounter), label);

}

static void

analyze(void)

{

    if (idle_keepgoing) {

        idle_count = 0;

        idle_count_max = 0;

        idle_keepgoing = 0;

        idle_end = 0;

    }

    plot_frame();

    update_progress();

}

static void

plotclick(GtkWidget * widget, gpointer data)