/*

 *  ALSA mixer console for Echoaudio soundcards.

 *  Copyright (C) 2003 Giuliano Pochini <pochini@shiny.it>

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; version 2 of the License.

 *

 *  This program 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 General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 */

#define EM_VERSION "%s Echomixer v" VERSION

/*******

  Remove the "//" if you want to compile Echomixer in reverse mode.

*******/

//#define REVERSE

/*******

 Constants marked with *M* can be modified to customize the interface.

*******/

#define BORDER		6			// *M* Inner border of GTK containers

#define SPACING		8			// *M* Spacing of control sections

// Graphic mixer constants

#define GM_BARWIDTH	5			// *M* Width of meters bars

#define XCELLBORDER	2			// *M* Space between the grid lines and the content of the cell

#define YCELLBORDER	2			// *M*

#define XCELLDIM	20			// *M* Width of the cell

#define YCELLDIM	32			// Height of the cell

#define XCELLTOT (1+XCELLBORDER*2+XCELLDIM)	// line + left border + cell + right border

#define YCELLTOT (1+YCELLBORDER*2+YCELLDIM)

#define XVOLUME (1+XCELLBORDER+3)		// Position of the volume slider

#define XMETER (1+XCELLBORDER-GM_BARWIDTH/2+13)	// Position of the VU bar

// VU-meter constants

#define VU_XGRAF	30			// Left margin of the graphic

#define VU_YGRAF	20			// Top margin

#define VU_BARWIDTH	6			// *M* Width of VU-meters bars

#define VU_BARSEP	2			// *M* Space between bars

#define SHORTSTEP	1			// *M* 1dB (when the users moves a slider with cursor keys)

#define LONGSTEP	6			// *M* 6dB (with Page up/down or clicking the background)

#define DIGITAL_MODES	16			// Max number of digital modes

#define ECHO_CLOCKS	8			// Max number of clock sources

#define INPUT 0

#define OUTPUT 1

#define ECHO_MAXAUDIO_IOS	32		// The maximum number of inputs + outputs

#define ECHO_MAXAUDIOINPUTS	32		// Max audio input channels

#define ECHO_MAXAUDIOOUTPUTS	32		// Max audio output channels

#define ECHOGAIN_MUTED		(-128)		// Minimum possible gain

#define ECHOGAIN_MINOUT		(-128)		// Min output gain (unit is 1dB)

#define ECHOGAIN_MAXOUT		6		// Max output gain (unit is 1dB)

#define ECHOGAIN_MININP		(-50)		// Min input gain (unit is 0.5dB)

#define ECHOGAIN_MAXINP		50		// Max input gain (unit is 0.5dB)

// GTK+ adjustment widgets have the mininum value at top and maximum at bottom,

// position, but we need the opposite. This function puts the scale upside-down.

#define INVERT(x)	(ECHOGAIN_MINOUT+ECHOGAIN_MAXOUT-(x))

#define IN_INVERT(x)	(ECHOGAIN_MININP+ECHOGAIN_MAXINP-(x))

// REAL is for debugging only.

#define REAL

//#define CTLID_DEBUG(x) printf x

#define CTLID_DEBUG(x)

#define UI_DEBUG(x)

//#define UI_DEBUG(x) printf x

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <gtk/gtk.h>

#include <gdk/gdk.h>

#include <alsa/asoundlib.h>

char card[64], cardId[16];

char dmodeName[DIGITAL_MODES][64], clocksrcName[DIGITAL_MODES][64], spdifmodeName[DIGITAL_MODES][64];

int nLOut, nIn, fdIn, fdOut, nPOut, ClockMask;

int ndmodes, nclocksrc, nspdifmodes;

int GMixerRow, GMixerColumn, Gang, AutoClock;

int lineinId, pcmoutId, lineoutId, mixerId, vmixerId, p4InId, p4OutId, dmodeId;

int clocksrcId, spdifmodeId, vuswitchId, vumetersId, channelsId, phantomId, automuteId;

int metersStreams, metersNumber, metersTypes;

int outvolCount;

int mouseY, mouseButton;

int dmodeVal, clocksrcVal, spdifmodeVal;

int VUwidth, VUheight, Mixwidth, Mixheight;

#define DONT_DRAW (ECHOGAIN_MUTED-1)

#define DONT_CHANGE (1<<31)

#define NOPOS 999999

struct geometry {

  int st;		// window status: 0 = hidden ; 1 = visible ; NOPOS = no stored setting

  GtkWidget *toggler;	// The toggle button that controls this window

  int x, y;

  int w, h;

} Mainw_geom, Miscw_geom, PVw_geom, LVw_geom, Mixerw_geom, Vmixerw_geom, VUw_geom, GMw_geom;

// This structure contains the first and the last row of each section of the graphic mixer window

struct {

  int VmixerFirst, VmixerLast;	// Rows

  int LineOut;			// There is only one row

  int Inputs;			// Rows

  int Outputs;			// Columns

} GMixerSection;

struct mixel {

  int id;

  int Gain;

};

snd_ctl_t *ctlhandle;

struct mixerControl_s {

  int input, inputs;

  int output, outputs;

  int id;

  GtkWidget *window;

  GtkWidget *volume[ECHO_MAXAUDIOOUTPUTS];

  GtkWidget *label[ECHO_MAXAUDIOOUTPUTS];

  GtkObject *adj[ECHO_MAXAUDIOOUTPUTS];

  GtkWidget *outsel[ECHO_MAXAUDIOOUTPUTS];

  GtkWidget *inpsel[ECHO_MAXAUDIOINPUTS];

  GtkWidget *vchsel[ECHO_MAXAUDIOOUTPUTS];

  struct mixel mixer[ECHO_MAXAUDIOOUTPUTS][ECHO_MAXAUDIOOUTPUTS];

} mixerControl, vmixerControl;

struct VolumeControl_s {

  int input, output;				// Currently selected channels

  int inputs, outputs;

  int id;

  GtkWidget *window;

  GtkWidget *volume[ECHO_MAXAUDIOOUTPUTS];

  GtkWidget *label[ECHO_MAXAUDIOOUTPUTS];

  GtkObject *adj[ECHO_MAXAUDIOOUTPUTS];

  int Gain[ECHO_MAXAUDIOOUTPUTS];

} lineinControl, lineoutControl, pcmoutControl;

struct NominalLevelControl_s {

  int id;

  int Channels;

  char Level[ECHO_MAXAUDIOINPUTS];

  GtkWidget *Button[ECHO_MAXAUDIOINPUTS];

} NominalIn, NominalOut;

struct SwitchControl_s {

  int id;

  int value;

  GtkWidget *Button;

} PhantomPower, Automute;

GtkWidget *clocksrc_menuitem[ECHO_CLOCKS];

GtkWidget *dmodeOpt, *clocksrcOpt, *spdifmodeOpt, *phantomChkbutton, *autoclockChkbutton;

GtkWidget *window, *Mainwindow, *Miscwindow, *LVwindow, *VUwindow, *GMwindow;

GtkWidget *VUdarea, *Mixdarea;

gint VUtimer, Mixtimer, clocksrctimer;

GdkGC *gc=0;

static GdkPixmap *VUpixmap = NULL;

static GdkPixmap *Mixpixmap = NULL;

GdkFont *fnt;

void Clock_source_activate(GtkWidget *widget, gpointer clk);

int CountBits(int n) {

  int c;

  c=0;

  while (n) {

    c++;

    n&=(n-1);

  }

  return(c);

}

void ClampOutputVolume(int *v) {

  if (*v>ECHOGAIN_MAXOUT)

    *v=ECHOGAIN_MAXOUT;

  else if (*v

    *v=ECHOGAIN_MINOUT;

}

void ClampInputVolume(int *v) {

  if (*v>ECHOGAIN_MAXINP)

    *v=ECHOGAIN_MAXINP;

  else if (*v

    *v=ECHOGAIN_MININP;

}

// -128 dB means muted, that is -infinite dB

int Add_dB (int a, int b) {

  if (a==ECHOGAIN_MINOUT || b==ECHOGAIN_MINOUT)

    return(ECHOGAIN_MINOUT);

  a+=b;

  if (a

    return(ECHOGAIN_MINOUT);

  return(a);

}

char *strOutGain(char *s, int g) {

  if (g==ECHOGAIN_MINOUT)

    strcpy(s, "mute");

  else

    sprintf(s, "%+d", g);

  return(s);

}

// Write an enumerated ALSA control

int SetEnum(int numid, int val) {

  int err;

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, numid==clocksrcId ? SND_CTL_ELEM_IFACE_PCM : SND_CTL_ELEM_IFACE_CARD);

  snd_ctl_elem_id_set_numid(id, numid);

  snd_ctl_elem_value_set_id(control, id);

  snd_ctl_elem_value_set_enumerated(control, 0, val);

  if ((err=snd_ctl_elem_write(ctlhandle, control)) < 0)

    printf("Control %s element write error: %s\n", card, snd_strerror(err));

  return(err);

}

// Read an enumerated ALSA control

int GetEnum(int numid) {

  int err, val;

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, numid==clocksrcId ? SND_CTL_ELEM_IFACE_PCM : SND_CTL_ELEM_IFACE_CARD);

  snd_ctl_elem_id_set_numid(id, numid);

  snd_ctl_elem_value_set_id(control, id);

  if ((err=snd_ctl_elem_read(ctlhandle, control)) < 0)

    printf("Control %s element read error: %s\n", card, snd_strerror(err));

  val=snd_ctl_elem_value_get_enumerated(control, 0);

  return(val);

}

// Turn VU-meters on/off

void SetVUmeters(int onoff) {

  static signed char oncount=0;

  int err;

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  if (onoff)

    oncount++;

  else

    if (--oncount<0)

      oncount=0;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_CARD);

  snd_ctl_elem_id_set_numid(id, vuswitchId);

  snd_ctl_elem_value_set_id(control, id);

  snd_ctl_elem_value_set_integer(control, 0, !!oncount);

  if ((err=snd_ctl_elem_write(ctlhandle, control)) < 0) {

    printf("Control %s element write error: %s\n", card, snd_strerror(err));

  }

}

void GetVUmeters(int *InLevel, int *InPeak, int *OutLevel, int *OutPeak, int *VirLevel, int *VirPeak) {

  int err, i, m;

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);

  snd_ctl_elem_id_set_numid(id, vumetersId);

  snd_ctl_elem_value_set_id(control, id);

  if ((err = snd_ctl_elem_read(ctlhandle, control)) < 0) {

    printf("Control %s element read error: %s\n", card, snd_strerror(err));

    return;

  }

  m=0;

  for (i=0; i

    OutLevel[i]=snd_ctl_elem_value_get_integer(control, m++);

    OutPeak[i]=snd_ctl_elem_value_get_integer(control, m++);

  }

  m=1*metersNumber*metersTypes;

  for (i=0; i

    InLevel[i]=snd_ctl_elem_value_get_integer(control, m++);

    InPeak[i]=snd_ctl_elem_value_get_integer(control, m++);

  }

  if (metersStreams==3) {	// Has PCM levels (Mia only) ?

    m=2*metersNumber*metersTypes;

#ifdef REAL

    for (i=0; i

      VirLevel[i]=snd_ctl_elem_value_get_integer(control, m++);

      VirPeak[i]=snd_ctl_elem_value_get_integer(control, m++);

    }

#else

    for (i=0; i

      VirLevel[i]=i*5-100;

      VirPeak[i]=i*5-90;

    }

#endif

  }

}

#ifdef REVERSE

// Enable/disable widgets that control ADAT digital channels

void SetSensitivity(int enable) {

  int i;

  for (i=fdOut+2; i

    if (!enable && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mixerControl.outsel[i])))

      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mixerControl.outsel[0]), TRUE);

    if (mixerId)

      gtk_widget_set_sensitive(mixerControl.outsel[i], enable);

    if (vmixerId) {

      if (!enable && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(vmixerControl.outsel[i])))

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(vmixerControl.outsel[0]), TRUE);

      gtk_widget_set_sensitive(vmixerControl.outsel[i], enable);

    }

    if (pcmoutId) {

      gtk_widget_set_sensitive(pcmoutControl.label[i], enable);

      gtk_widget_set_sensitive(pcmoutControl.volume[i], enable);

    }

    // Line-out control is always present

    gtk_widget_set_sensitive(lineoutControl.label[i], enable);

    gtk_widget_set_sensitive(lineoutControl.volume[i], enable);

  }

  for (i=fdIn+2; i

    gtk_widget_set_sensitive(mixerControl.label[i], enable);

    gtk_widget_set_sensitive(mixerControl.volume[i], enable);

  }

  if (!enable && mixerControl.input>=fdIn+2)

    mixerControl.input=0;

}

#else // REVERSE

// Enable/disable widgets that control ADAT digital channels

void SetSensitivity(int enable) {

  int i;

  for (i=fdIn+2; i

    if (!enable && gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mixerControl.inpsel[i])))

      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mixerControl.inpsel[0]), TRUE);

    gtk_widget_set_sensitive(mixerControl.inpsel[i], enable);

  }

  for (i=fdOut+2; i

    if (mixerId) {

      gtk_widget_set_sensitive(mixerControl.label[i], enable);

      gtk_widget_set_sensitive(mixerControl.volume[i], enable);

    }

    if (vmixerId) {

      gtk_widget_set_sensitive(vmixerControl.label[i], enable);

      gtk_widget_set_sensitive(vmixerControl.volume[i], enable);

    }

    if (pcmoutId) {

      gtk_widget_set_sensitive(pcmoutControl.label[i], enable);

      gtk_widget_set_sensitive(pcmoutControl.volume[i], enable);

    }

    // Line-out control is always present

    gtk_widget_set_sensitive(lineoutControl.label[i], enable);

    gtk_widget_set_sensitive(lineoutControl.volume[i], enable);

  }

  if (!enable && mixerControl.output>=fdOut+2)

    mixerControl.output=0;

  if (vmixerId && !enable && vmixerControl.output>=fdOut+2)

    vmixerControl.output=0;

}

#endif // REVERSE

// Read current control settings.

int ReadControl(int *vol, int channels, int numid, int iface) {

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  int err, ch;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, iface);

  snd_ctl_elem_id_set_numid(id, numid);

  snd_ctl_elem_value_set_id(control, id);

  if ((err=snd_ctl_elem_read(ctlhandle, control))<0) {

    printf("Control %s element read error: %s\n", card, snd_strerror(err));

    return(err);

  }

  for (ch=0; ch

    vol[ch]=snd_ctl_elem_value_get_integer(control, ch);

  return(0);

}

void ReadNominalLevels(struct NominalLevelControl_s *NominalLevel) {

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  int err, i;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);

  snd_ctl_elem_id_set_numid(id, NominalLevel->id);

  snd_ctl_elem_value_set_id(control, id);

  if ((err=snd_ctl_elem_read(ctlhandle, control))<0)

    printf("Control %s element read error: %s\n", card, snd_strerror(err));

  for (i=0; i<NominalLevel->Channels; i++)

    NominalLevel->Level[i]=snd_ctl_elem_value_get_integer(control, i);

}

int SetMixerGain(struct mixel *mxl, int Gain) {

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  int err;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);

  snd_ctl_elem_id_set_numid(id, mxl->id);

  snd_ctl_elem_value_set_id(control, id);

  snd_ctl_elem_value_set_integer(control, 0, Gain);

  if ((err = snd_ctl_elem_write(ctlhandle, control)) < 0) {

    printf("Control %s element write error: %s\n", card, snd_strerror(err));

    return(err);

  }

  return(0);

}

// Read current (v)mixer settings.

void ReadMixer(struct mixerControl_s *mixer) {

  int err, in, out;

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

#ifndef REAL

    return;

#endif

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);

  for (out=0; out<mixer->outputs; out++) {

    for (in=0; in<mixer->inputs; in++) {

      snd_ctl_elem_id_set_numid(id, mixer->mixer[out][in].id);

      snd_ctl_elem_value_set_id(control, id);

      if ((err=snd_ctl_elem_read(ctlhandle, control))<0)

        printf("InitMixer - Control %s element read error: %s\n", card, snd_strerror(err));

      mixer->mixer[out][in].Gain=snd_ctl_elem_value_get_integer(control, 0);

    }

  }

}

void GetChannels(void) {

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  int err;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_HWDEP);

  snd_ctl_elem_id_set_numid(id, channelsId);

  snd_ctl_elem_value_set_id(control, id);

  if ((err = snd_ctl_elem_read(ctlhandle, control)) < 0) {

    printf("GetChannels() read error: %s\n", snd_strerror(err));

    exit(1);

  }

  if (!nIn) {	// Only read the first time (mainly for debugging, see #define REAL)

    nIn=snd_ctl_elem_value_get_integer(control, 0);	// Number of input channels

    fdIn=snd_ctl_elem_value_get_integer(control, 1);	// First digital in (= number of analog input channels)

    nLOut=snd_ctl_elem_value_get_integer(control, 2);	// Number of output channels

    fdOut=snd_ctl_elem_value_get_integer(control, 3);	// First digital out

    nPOut=snd_ctl_elem_value_get_integer(control, 4);	// Number of virtual output channels (==nLOut on non-vmixer cards)

    mixerControl.outputs = nLOut;

    mixerControl.inputs = nIn;

    if (vmixerId) {

      vmixerControl.outputs = nLOut;

      vmixerControl.inputs = nPOut;

      /* For outputs and inputs. */

      metersStreams = 2;

    } else {

      /* For outputs, inputs and system outputs. */

      metersStreams = 3;

    }

    /* For the number of channels. */

    metersNumber = 16;

    /* For each of levels and peaks. */

    metersTypes = 2;

  }

  ClockMask=snd_ctl_elem_value_get_integer(control, 5);	// Bitmask of available input clocks

}

// Read what input clocks are valid and (de)activate the pop-down menu items accordingly

gint CheckInputs(gpointer unused) {

  int clk, valid, source;

  GetChannels();

  source=-1;

  // Switch to internal if the source is not available

  if (AutoClock>=0 && !(ClockMask & (1<

    source=0;

  for (clk=0; clk

    valid=!!(ClockMask & (1<

    gtk_widget_set_sensitive(clocksrc_menuitem[clk], valid);

    if (clk==AutoClock && valid)

      source=AutoClock;

  }

  if (source>=0 && source!=clocksrcVal) {

    // Set the clock source, but do not change the value of AutoClock

    Clock_source_activate(clocksrc_menuitem[source], (gpointer)(long)(source|DONT_CHANGE));

    gtk_option_menu_set_history(GTK_OPTION_MENU(clocksrcOpt), clocksrcVal);

  }

  return(TRUE);

}

void DrawBar(int x, int y, int level, int peak, int gain) {

  GdkColor Bars={0x00FF00, 0, 0, 0};

  GdkColor Bars1={0x000000, 0, 0, 0};

  GdkColor Peak={0x1BABFF, 0, 0, 0};

  GdkColor Level={0xC0B000, 0, 0, 0};

  int db;

  x=XMETER+XCELLTOT*x;

  y=YCELLTOT*y+YCELLBORDER;

  if (level>ECHOGAIN_MUTED) {

    // Draw the "integer" part of the bar

    db=level>>2;

    gdk_gc_set_foreground(gc, &Bars;;

    gdk_draw_rectangle(Mixpixmap, gc, TRUE, x, y-db, GM_BARWIDTH, YCELLDIM+db);

    // Draw the antialiased part

    Bars1.pixel=(level&3) << (6 + 8);	// 4 levels (256/4==64==2^6) of green (2^8)

    if (Bars1.pixel) {

      gdk_gc_set_foreground(gc, &Bars1);

      gdk_draw_rectangle(Mixpixmap, gc, TRUE, x, y-db-1, GM_BARWIDTH, 1);

    }

  }

  // Draw the peak

  if (peak>ECHOGAIN_MUTED) {

    db=peak>>2;

    gdk_gc_set_foreground(gc, &Peak);

    gdk_draw_rectangle(Mixpixmap, gc, TRUE, x, y-db, GM_BARWIDTH, 1);

  }

  // Draw the mixer gain

  if (gain>=ECHOGAIN_MUTED) {

    db=gain>>2;

    gdk_gc_set_foreground(gc, &Level);

    gdk_draw_rectangle(Mixpixmap, gc, TRUE, x-XMETER+XVOLUME, y, 1, YCELLDIM);

    gdk_draw_rectangle(Mixpixmap, gc, TRUE, x-XMETER+XVOLUME-2, y-db, 5, 1);

  }

}

// Draw the matrix mixer

gint DrawMixer(gpointer unused) {

  GdkRectangle update_rect;

  int InLevel[ECHO_MAXAUDIOINPUTS];

  int InPeak[ECHO_MAXAUDIOINPUTS];

  int OutLevel[ECHO_MAXAUDIOOUTPUTS];

  int OutPeak[ECHO_MAXAUDIOOUTPUTS];

  int VirLevel[ECHO_MAXAUDIOOUTPUTS];

  int VirPeak[ECHO_MAXAUDIOOUTPUTS];

  static int InClip[ECHO_MAXAUDIOINPUTS];

  static int OutClip[ECHO_MAXAUDIOOUTPUTS];

  char str[8];

  int i, o, dB;

  GdkColor Grid={0x787878, 0, 0, 0};

  GdkColor Labels={0x9694C4, 0, 0, 0};

  GdkColor Hilight={0x000078, 0, 0, 0};

  GdkColor Hilight2={0x600000, 0, 0, 0};

  if (!Mixpixmap)

    return(TRUE);

  update_rect.x = 0;

  update_rect.y = 0;

  update_rect.width = Mixwidth;

  update_rect.height = Mixheight;

  GetVUmeters(InLevel, InPeak, OutLevel, OutPeak, VirLevel, VirPeak);

  if (!gc) {

    gc=gdk_gc_new(gtk_widget_get_parent_window(Mixdarea));

    for (i=0; i

      InClip[i]=0;

    for (i=0; i

      OutClip[i]=0;

  }

  gdk_draw_rectangle(Mixpixmap, Mixdarea->style->black_gc, TRUE, 0, 0, Mixwidth, Mixheight);

  // Highlight

  gdk_gc_set_foreground(gc, &Hilight);

  gdk_draw_rectangle(Mixpixmap, gc, TRUE, 0, YCELLTOT*mixerControl.input, XCELLTOT*(mixerControl.output+1), YCELLTOT);

  gdk_draw_rectangle(Mixpixmap, gc, TRUE, XCELLTOT*(mixerControl.output+1), YCELLTOT*mixerControl.input, XCELLTOT, Mixheight);

  if (vmixerId) {

    gdk_gc_set_foreground(gc, &Hilight2);

    gdk_draw_rectangle(Mixpixmap, gc, TRUE, 0, YCELLTOT*(GMixerSection.VmixerFirst+vmixerControl.input), XCELLTOT*(vmixerControl.output+1), YCELLTOT);

    gdk_draw_rectangle(Mixpixmap, gc, TRUE, XCELLTOT*(vmixerControl.output+1), YCELLTOT*(GMixerSection.VmixerFirst+vmixerControl.input), XCELLTOT, Mixheight);

  }

  // Draw the grid

  gdk_gc_set_font(gc, fnt);

  // Horizontal lines and input channel labels

  for (i=0; i

    gdk_gc_set_foreground(gc, &Grid);

    gdk_draw_rectangle(Mixpixmap, gc, TRUE, 0, YCELLTOT*(i+1)-1, Mixwidth, 1);

    if (i

      sprintf(str, "A%d", i);		// Analog

    else if (i

      sprintf(str, "D%d", i-fdIn);	// Digital

    else

      sprintf(str, "V%d", i-nIn);	// Virtual

    gdk_gc_set_foreground(gc, &Labels);

    gdk_draw_string(Mixpixmap, fnt, gc, 1, YCELLTOT*i+(YCELLTOT/2)+4, str);

  }

  // Vertical lines and output channel labels

  for (o=0; o

    gdk_gc_set_foreground(gc, &Grid);

    gdk_draw_rectangle(Mixpixmap, gc, TRUE, XCELLTOT*(o+1), 0, 1, Mixheight);

    if (o

      sprintf(str, "A%d", o);

    else

      sprintf(str, "D%d", o-fdOut);

    gdk_gc_set_foreground(gc, &Labels);

    gdk_draw_string(Mixpixmap, fnt, gc, XCELLTOT*(o+1)+(XCELLTOT/2)-6, YCELLTOT*GMixerSection.LineOut+YCELLTOT+8, str);

  }

  gdk_draw_string(Mixpixmap, fnt, gc, 1, 8, "In");

  gdk_draw_string(Mixpixmap, fnt, gc, 1, YCELLTOT*GMixerSection.LineOut+YCELLTOT+8, "Out");

  gdk_gc_set_foreground(gc, &Grid);

  gdk_draw_rectangle(Mixpixmap, gc, TRUE, 0, YCELLTOT*(GMixerSection.LineOut+1)-1, Mixwidth, 1);

  // Draw input levels and peaks

  for (i=0; i

    DrawBar(0, i, InLevel[i], InPeak[i], DONT_DRAW);

  // Draw vchannels levels and peaks (Vmixer cards only)

  if (vmixerId) {

    for (i=0; i

      DrawBar(0, i+GMixerSection.VmixerFirst, VirLevel[i], VirPeak[i], DONT_DRAW);

  }

  // Draw output levels, peaks and volumes

  for (o=0; o

    DrawBar(o+1, GMixerSection.LineOut, OutLevel[o], OutPeak[o], lineoutControl.Gain[o]);

  // Draw monitor mixer elements

  for (o=0; o

    for (i=0; i

      dB=Add_dB(mixerControl.mixer[o][i].Gain, InLevel[i]);

      DrawBar(o+1, i, dB, DONT_DRAW, mixerControl.mixer[o][i].Gain);

    }

  }

  // Draw vmixer elements (Vmixer cards only)

  if (vmixerId) {

    for (o=0; o

      for (i=0; i

        dB=Add_dB(vmixerControl.mixer[o][i].Gain, VirLevel[i]);

        DrawBar(o+1, i+GMixerSection.VmixerFirst, dB, DONT_DRAW, vmixerControl.mixer[o][i].Gain);

      }

  }

  gtk_widget_draw(Mixdarea, &update_rect);

  return(TRUE);

}

// Draw the VU-meter

gint DrawVUmeters(gpointer unused) {

  GdkRectangle update_rect;

  int InLevel[ECHO_MAXAUDIOINPUTS];

  int InPeak[ECHO_MAXAUDIOINPUTS];

  int OutLevel[ECHO_MAXAUDIOOUTPUTS];

  int OutPeak[ECHO_MAXAUDIOOUTPUTS];

  int VirLevel[ECHO_MAXAUDIOOUTPUTS];

  int VirPeak[ECHO_MAXAUDIOOUTPUTS];

  static int InClip[ECHO_MAXAUDIOINPUTS];

  static int OutClip[ECHO_MAXAUDIOOUTPUTS];

  int i, x, dB;

  char str[16];

  GdkColor Selected={0xC86060, 0, 0, 0};

  GdkColor Grid={0x9694C4, 0, 0, 0};

  GdkColor Grid2={0x646383, 0, 0, 0};

  GdkColor dBValues={0x00B000, 0, 0, 0};

  GdkColor AnBars={0x00E0B8, 0, 0, 0};

  GdkColor DiBars={0x98E000, 0, 0, 0};

  GdkColor ClipPeak={0, 0, 0, 0};

  GdkColor Peak={0x00FF00, 0, 0, 0};

  if (!VUpixmap)

    return(TRUE);

  update_rect.x = 0;

  update_rect.y = 0;

  update_rect.width = VUwidth;

  update_rect.height = VUheight;

  GetVUmeters(InLevel, InPeak, OutLevel, OutPeak, VirLevel, VirPeak);

  if (!gc) {

    gc=gdk_gc_new(gtk_widget_get_parent_window(VUdarea));

    for (i=0; i

      InClip[i]=0;

    for (i=0; i

      OutClip[i]=0;

  }

  // Clear the image

  gdk_draw_rectangle(VUpixmap, VUdarea->style->black_gc, TRUE, 0, 0, VUwidth, VUheight);

  // Draw the dB scale and the grid

  gdk_gc_set_font(gc, fnt);

  gdk_gc_set_foreground(gc, &Peak);

  gdk_draw_string(VUpixmap, fnt, gc, 2, VU_YGRAF-12+4, "  dB");

  for (i=0; i<=120; i+=12) {

    sprintf(str, "%4d", -i);

    gdk_gc_set_foreground(gc, &dBValues);

    gdk_draw_string(VUpixmap, fnt, gc, 2, VU_YGRAF+i+4, str);

    gdk_gc_set_foreground(gc, &Grid);

    gdk_draw_rectangle(VUpixmap, gc, TRUE, VU_XGRAF, VU_YGRAF+i, VUwidth-VU_XGRAF, 1);

  }

  gdk_gc_set_foreground(gc, &Grid2);

  gdk_draw_rectangle(VUpixmap, gc, TRUE, VU_XGRAF, VU_YGRAF+128, VUwidth-VU_XGRAF, 1);

  x=VU_XGRAF+VU_BARSEP;

  // Draw inputs

  for (i=0; i

    if (i

      gdk_gc_set_foreground(gc, &AnBars);

    else

      gdk_gc_set_foreground(gc, &DiBars);

    dB=InLevel[i];

    gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF-dB, VU_BARWIDTH, 129+VU_YGRAF-(VU_YGRAF-dB));

    dB=InPeak[i];

    if (dB==0)

      InClip[i]=64;

    if (InClip[i]) {

      InClip[i]--;

      ClipPeak.pixel=(InClip[i]<<18)+((255-(InClip[i]*3))<<8);

      gdk_gc_set_foreground(gc, &ClipPeak);

    } else {

      gdk_gc_set_foreground(gc, &Peak);

    }

    gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF-dB, VU_BARWIDTH, 1);

    if (mixerControl.input==i) {

      gdk_gc_set_foreground(gc, &Selected);

      gdk_draw_rectangle(VUpixmap, gc, TRUE, x+1, VU_YGRAF+128+3, VU_BARWIDTH-2, 1);

      gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF+128+4, VU_BARWIDTH, 1);

    }

    x+=VU_BARWIDTH+VU_BARSEP;

  }

  // Draw outputs

  x+=VU_BARWIDTH+VU_BARSEP;

  for (i=0; i

    if (i

      gdk_gc_set_foreground(gc, &AnBars);

    else

      gdk_gc_set_foreground(gc, &DiBars);

    dB=OutLevel[i];

    gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF-dB, VU_BARWIDTH, 129+VU_YGRAF-(VU_YGRAF-dB));

    dB=OutPeak[i];

    if (dB==0)

      OutClip[i]=64;

    if (OutClip[i]) {

      OutClip[i]--;

      ClipPeak.pixel=(OutClip[i]<<18)+((255-(OutClip[i]*3))<<8);

      gdk_gc_set_foreground(gc, &ClipPeak);

    } else {

      gdk_gc_set_foreground(gc, &Peak);

    }

    gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF-dB, VU_BARWIDTH, 1);

    if (mixerControl.output==i) {

      gdk_gc_set_foreground(gc, &Selected);

      gdk_draw_rectangle(VUpixmap, gc, TRUE, x+1, VU_YGRAF+128+3, VU_BARWIDTH-2, 1);

      gdk_draw_rectangle(VUpixmap, gc, TRUE, x, VU_YGRAF+128+4, VU_BARWIDTH, 1);

    }

    x+=VU_BARWIDTH+VU_BARSEP;

  }

  gtk_widget_draw(VUdarea, &update_rect);

  return(TRUE);

}

///////////////////// GUI events

#ifdef REVERSE

void Mixer_Output_selector_clicked(GtkWidget *widget, gpointer och) {

  int ich, val;

  snd_ctl_elem_id_t *id;

  snd_ctl_elem_value_t *control;

  if (mixerControl.output==(int)och)

    return;

  mixerControl.output=(int)och;

  snd_ctl_elem_id_alloca(&id;;

  snd_ctl_elem_value_alloca(&control);

  snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);

  for (ich=0; ich