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

levelmeters.c - Stereo level meters

Copyright (C) 2000 by Jaroslav Kysela <perex@perex.cz>

Missing peak-level meter feature, and associated rewrite of metering for

lower X resource usage, along with using a logarithmic display that attempts

correspondence to mixer labels; updating text display of these levels in

dBFS appears in their associated panels.

Copyright (C) 2010 by Niels Mayer ( http://nielsmayer.com ).

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; either version 2

of the License, or (at your option) any later version.

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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

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

#include <math.h>

#include "envy24control.h"

static GdkGC *penWhiteLight[21] = { NULL, };

static GdkGC *penGreenLight[21] = { NULL, };

static GdkGC *penForeground[21] = { NULL, };

static GdkGC *penBackground[21] = { NULL, };

static GdkGC *penOrangeLight[21] = { NULL, };

static GdkGC *penRedLight[21] = { NULL, };

static GdkColor *peak_label_color = NULL; /* NPM set in level_meters_configure_event() */

static GdkPixmap *pixmap[21] = { NULL, };

static snd_ctl_elem_value_t *peaks;

extern int input_channels, output_channels, pcm_output_channels, spdif_channels, view_spdif_playback;

static void update_peak_switch(void) {

int err;

if ((err = snd_ctl_elem_read(ctl, peaks)) < 0)

g_print("Unable to read peaks: %s\n", snd_strerror(err));

}

/*

* Niels Mayer (NPM) Jul-11-10: Fixing https://bugzilla.redhat.com/show_bug.cgi?id=602903

* by implementing peak-level meters. The http://alsa.cybermirror.org/manuals/icensemble/envy24.pdf

* soundchip provides hardware level meters and these are returned via ALSA as such:

* >> amixer -c M66 cget iface=PCM,name='Multi Track Peak',numid=45

* ; type=INTEGER,access=r-------,values=22,min=0,max=255,step=0

* : values=0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,198,255,198

* These globals store the peak levels of the meters across callbacks.

*/

#define RESET -1

// NPM: Note special case in original envy24control code, which puts stereo mix track at

// "index 0" which is actually "(peaks, 20)" and "(peaks, 21)" cases below

// thus peak_lmix <--> peak_levels[IDX_LMIX] ; peak_rmix <--> peak_levels[IDX_RMIX]

static int peak_levels[MULTI_TRACK_PEAK_CHANNELS] = {0,};

static int peak_changed[MULTI_TRACK_PEAK_CHANNELS] = {0,};

static int previous_levels[MULTI_TRACK_PEAK_CHANNELS] = {0,};

/* NPM: changed for https://bugzilla.redhat.com/show_bug.cgi?id=602903 */

static void get_levels(int idx, int *l1, int *l2) {

*l1 = *l2 = 0;

if (idx == 0) { /* "if (stereo)" -- special case idx=0 as digital mix pair */

if ((peak_changed[IDX_LMIX] != RESET) && (peak_changed[IDX_RMIX] != RESET)) { /* don't change values if doing "Reset Peaks" */

if ((*l1 = snd_ctl_elem_value_get_integer(peaks, IDX_LMIX)) > peak_levels[IDX_LMIX]) {

peak_levels[IDX_LMIX] = (*l1);

peak_changed[IDX_LMIX] = TRUE;

}

if ((*l2 = snd_ctl_elem_value_get_integer(peaks, IDX_RMIX)) > peak_levels[IDX_RMIX]) {

peak_levels[IDX_RMIX] = (*l2);

peak_changed[IDX_RMIX] = TRUE;

}

}

}

else {

if (peak_changed[idx-1] != RESET) {

if ((*l1 = snd_ctl_elem_value_get_integer(peaks, idx - 1)) > peak_levels[idx - 1]) {

peak_levels[idx - 1] = (*l1);

peak_changed[idx - 1] = TRUE;

}

}

}

}

static GdkGC *get_pen(int idx, int nRed, int nGreen, int nBlue) {

GdkColor *c;

GdkGC *gc;

c = (GdkColor *)g_malloc(sizeof(GdkColor));

c->red = nRed;

c->green = nGreen;

c->blue = nBlue;

gdk_color_alloc(gdk_colormap_get_system(), c);

gc = gdk_gc_new(pixmap[idx]);

gdk_gc_set_foreground(gc, c);

return gc;

}

static int get_index(const gchar *name) {

int result;

if (!strcmp(name, "DigitalMixer"))

return 0;

result = atoi(name + 5);

if (result < 1 || result > 20) {

g_print("Wrong drawing area ID: %s\n", name);

gtk_main_quit();

}

return result;

}

/*

* NPM: per http://alsa.cybermirror.org/manuals/icensemble/envy24.pdf the

* the values in each entry of iface=PCM,name='Multi Track Peak',numid=45

* represent: "Peak data derived from the absolute value of 9 msb. 00h

* min - FFh max volume. Reading the register resets the meter to 00h."

*/

//NPM difft colors for -1dB, -3dB, and -6dB peak levels

#define GET_COLOR_FOR_PEAKLEVEL(level) \

(level > 228) \

? (penRedLight[idx]) \

: ((level > 181) \

? (penOrangeLight[idx]) \

: ((level > 128) \

? (penWhiteLight[idx]) \

: (penGreenLight[idx])))

/*

* NPM: Called by redraw_meters(), this is a special case for when "Reset

* Peaks" is clicked: then just refresh meters, ignore value, clear RESET

* and let the next pass-through draw for the first time in the cleared

* meter...

*/

static void draw_meters_reset(int idx, int width, int height,

int stereo, int segment_width) {

// GdkColor color;

GtkWidget* lbl;

// if (!gdk_color_parse("bg", &color))

// g_print("gdk_color_parse('bg') fail\n");

gdk_draw_rectangle(pixmap[idx],

penBackground[idx],

TRUE,

//X

6,

//Y

0,

//WIDTH

segment_width,

//HEIGHT

height

);

/* NPM: Reset peak labels for "Monitor Inputs" and "Monitor PCMs" panels */

gtk_label_set_text(GTK_LABEL((stereo) ? peak_label[IDX_LMIX] : peak_label[idx-1]),

peak_level_to_db((stereo) ? peak_levels[IDX_LMIX] : peak_levels[idx-1])); /* put new value in label */

gtk_widget_modify_fg((stereo) ? peak_label[IDX_LMIX] : peak_label[idx-1],

GTK_STATE_NORMAL, NULL);

/* NPM: Reset "Analog Volume" panel's peak levels -- never happens for "stereo" case */

if (!stereo) {

/* NPM: Reset peak labels for DACs in "Analog Volume" panel */

if (((idx-1) >= 0) && ((idx-1) < envy_dac_volumes())) { /* index 0-8 corresponds to one of the eight DAC's */

if (((idx-1) < MAX_OUTPUT_CHANNELS) /* make sure within bounds of dac_peak_label[] */

&& (lbl = dac_peak_label[idx-1]) != NULL) {

gtk_label_set_text(GTK_LABEL(lbl), peak_level_to_db(peak_levels[idx-1])); /* put new value in label */

gtk_widget_modify_fg(lbl, GTK_STATE_NORMAL, NULL); /* reset fg color */

}

}

/* NPM: Reset peak labels for ADCs in "Analog Volume" panel */

else if (((idx-1) >= (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)) /* ADC channels begin at 11 = MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS */

&& ((idx-1) < (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS + envy_adc_volumes()))) { /* ADC channels end at 19 */

if ((((idx-1) - (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)) < MAX_INPUT_CHANNELS) /* make sure within bounds of adc_peak_label[] */

&& (lbl = adc_peak_label[(idx-1) - (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)]) != NULL) {

gtk_label_set_text(GTK_LABEL(lbl), peak_level_to_db(peak_levels[idx-1])); /* put new value in label */

gtk_widget_modify_fg(lbl, GTK_STATE_NORMAL, NULL); /* reset fg color */

}

}

}

if (stereo) {

gdk_draw_rectangle(pixmap[idx],

penBackground[idx],

TRUE,

//X

2 + (width / 2),

//Y

0,

//WIDTH

segment_width,

//HEIGHT

height

);

/* put new value in label */

gtk_label_set_text(GTK_LABEL(peak_label[IDX_RMIX]), peak_level_to_db(peak_levels[IDX_RMIX]));

gtk_widget_modify_fg(peak_label[IDX_RMIX], GTK_STATE_NORMAL, NULL);

peak_changed[IDX_LMIX] = FALSE;

peak_changed[IDX_RMIX] = FALSE;

}

else {

peak_changed[idx-1] = FALSE;

}

}

/*

* NPM: Called through redraw_meters(), via draw_meters_and_peaks(),

* this handles updating gtk labels/colors related to updated peak values.

* Note 'index' [0 to MULTI_TRACK_PEAK_CHANNELS-1] into global peak_label[]

* which is initialized by envy24control.c:create_mixer_frame().

*/

static void draw_peak_labels(int index, int stereo, int peak1_level, int peak2_level) {

GtkWidget* lbl;

gtk_label_set_text(GTK_LABEL((stereo) ? peak_label[IDX_LMIX] : peak_label[index]),

peak_level_to_db(peak1_level)); /* put new value in label */

if (peak1_level >= MAX_METERING_LEVEL) { /* if at 0dB, make label red; RESET reverts to normal color */

lbl = (stereo) ? peak_label[IDX_LMIX] : peak_label[index];

gtk_widget_modify_fg(lbl, GTK_STATE_NORMAL, peak_label_color);

}

/* NPM: Update "Analog Volume" panel's peak levels: the normal non-"stereo"

case of single channel peak monitors of input or PCMs */

if (!stereo) {

/* NPM: Update peak labels for DACs in "Analog Volume" panel */

if ((index >= 0) && (index < envy_dac_volumes())) { /* index 0-8 corresponds to one of the eight DAC's */

if ((index < MAX_OUTPUT_CHANNELS) /* make sure within bounds of dac_peak_label[] */

&& (lbl = dac_peak_label[index]) != NULL) {

gtk_label_set_text(GTK_LABEL(lbl), peak_level_to_db(peak1_level)); /* put new value in label */

if (peak1_level >= MAX_METERING_LEVEL)

gtk_widget_modify_fg(lbl, GTK_STATE_NORMAL, peak_label_color);

}

}

/* NPM: Update peak labels for ADCs in "Analog Volume" panel */

else if ((index >= (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)) /* ADC channels begin at 11 = MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS */

&& (index <= (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS + envy_adc_volumes()))) { /* ADC channels end at 19 */

if (((index - (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)) < MAX_INPUT_CHANNELS) /* make sure within bounds of adc_peak_label[] */

&& (lbl = adc_peak_label[index - (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)]) != NULL) {

gtk_label_set_text(GTK_LABEL(lbl), peak_level_to_db(peak1_level)); /* put new value in label */

if (peak1_level >= MAX_METERING_LEVEL)

gtk_widget_modify_fg(lbl, GTK_STATE_NORMAL, peak_label_color);

}

}

}

/* Handle special "stereo" case for right-channel of digital mixer */

else if (peak_changed[IDX_RMIX]) { //for stereo, draw RMIX, but skip redraw if same

gtk_label_set_text(GTK_LABEL(peak_label[IDX_RMIX]),

peak_level_to_db(peak2_level)); /* put new value in label */

if (peak2_level >= MAX_METERING_LEVEL) /* if at 0dB, make label "selected"; RESET reverts to normal color */

gtk_widget_modify_fg(peak_label[IDX_RMIX], GTK_STATE_NORMAL, peak_label_color);

}

}

//NPM: below, fudging value 51.0 instead of 48.164799306 = 20*log10(1/256)

// or 48.130803609 = 20*log10(1/255) so as to offset meter in direction of

// scale markings.

#define METER_LEVEL(level, height) \

((level==0) \

? 0 \

: ((int) (((double)(height)) \

* ((20.0 * log10(((double)(level)) \

/ ((double)MAX_METERING_LEVEL)) \

+ 51.0) \

/ 51.0) ))-1 \

)

/*

* NPM: Called by redraw_meters(), this is the normal case

* where we draw the meter and peaks, if changed.

*/

static void draw_meters_and_peaks(int idx, int width, int height, int level1, int level2,

int stereo, int segment_width) {

int meter1 = (stereo)

? METER_LEVEL(peak_levels[IDX_LMIX], height)

: METER_LEVEL(peak_levels[idx - 1], height);

int meter2 = (stereo)

? METER_LEVEL(peak_levels[IDX_RMIX], height)

: 0;

int peak1 = height - meter1;

int peak2 = (stereo) ? height - meter2: 0;

/*

* draw the peak(s), only if changed

*/

if ( (stereo && (peak_changed[IDX_LMIX] || peak_changed[IDX_RMIX]))

|| peak_changed[idx-1]) {

int peak2_level, peak1_level

= (stereo) ? peak_levels[IDX_LMIX] : peak_levels[idx-1];

/* Draw the peak as a single line */

gdk_draw_line(pixmap[idx],

GET_COLOR_FOR_PEAKLEVEL(peak1_level),

//X1

6,

//Y1

peak1 - 1,

//X2

5 + segment_width,

//Y2

peak1 - 1

);

/* Handle special "stereo" case for right-channel of digital mixer */

if (stereo && peak_changed[IDX_RMIX]) { //for stereo, draw RMIX, but skip redraw if same

peak2_level = peak_levels[IDX_RMIX];

gdk_draw_line(pixmap[idx],

GET_COLOR_FOR_PEAKLEVEL(peak2_level),

//X1

2 + (width / 2),

//Y1

peak2 - 1,

//X2

1 + (width / 2) + segment_width,

//Y2

peak2 - 1

);

}

else

peak2_level = -1; /* not used unless above case, which is also in draw_peak_labels()... but initialize anyways */

draw_peak_labels(idx-1, stereo, peak1_level, peak2_level);

/* reset peak_changed[] status now that new peak values rendered */

if (stereo) {

if (peak_changed[IDX_LMIX])

peak_changed[IDX_LMIX] = FALSE;

if (peak_changed[IDX_RMIX])

peak_changed[IDX_RMIX] = FALSE;

}

else {

peak_changed[idx-1] = FALSE;

}

}

/*

* draw the meters

* level1 at 0 --> no dspl

* level1 at 1 --> draw rectange at (1/255)*height

* level1 at 255 --> draw rectangle (255/255)*height

*/

meter1 = METER_LEVEL(level1, height);

if (stereo)

meter2 = METER_LEVEL(level2, height);

if (level1 != (stereo ? previous_levels[IDX_LMIX] : previous_levels[idx-1]) ) { //skip redraw if same

gdk_draw_rectangle(pixmap[idx],

penBackground[idx],

TRUE,

//X

6, // draw black downward from peak

//Y

peak1,

//WIDTH

segment_width,

//HEIGHT

height - meter1 - peak1

);

gdk_draw_rectangle(pixmap[idx],

penForeground[idx],

TRUE,

//X

6,

//Y

height - meter1,

//WIDTH

segment_width,

//HEIGHT

meter1

);

/* save current level value, skip redraw next time if no change */

if (stereo)

previous_levels[IDX_LMIX] = level1;

else

previous_levels[idx-1] = level1;

}

if (stereo && (level2 != previous_levels[IDX_RMIX])) { //for stereo, draw RMIX, but skip redraw if same

gdk_draw_rectangle(pixmap[idx],

penBackground[idx],

TRUE,

//X

2 + (width / 2),

//Y

peak2,

//WIDTH

segment_width,

//HEIGHT

height - meter2 - peak2

);

gdk_draw_rectangle(pixmap[idx],

penForeground[idx],

TRUE,

//X

2 + (width / 2),

//Y

height - meter2,

//WIDTH

segment_width,

//HEIGHT

meter2

);

/* save current level value, skip redraw next time if no change */

previous_levels[IDX_RMIX] = level2;

}

}

static void redraw_meters(int idx, int width, int height, int level1, int level2) {

int stereo = (idx == 0);

int segment_width = (stereo)

? (width / 2) - 8

: width - 12;

if ( (stereo && ((peak_changed[IDX_LMIX] == RESET) || (peak_changed[IDX_RMIX] == RESET)))

|| peak_changed[idx-1] == RESET) //needs full refresh, reset peaks button was clicked

draw_meters_reset(idx, width, height, stereo, segment_width);

else

draw_meters_and_peaks(idx, width, height, level1, level2, stereo, segment_width);

}

/* NPM: called out of level_meters_configure_event() at initialization to

pickup foreground color for level metering from --lights_color

command-line, or create default. */

static void levelmeters_init_fg(GtkWidget* widget, GdkGC *gc) {

if (meter_fg == NULL) { /* if --lights_color command-line argument not provided */

meter_fg = (GdkColor *)g_malloc(sizeof(GdkColor)); /* free()'d on exit() */

if (!gdk_color_parse("#1e90ff", meter_fg)) { /* "dodgerblue" per http://en.wikipedia.org/wiki/X11_color_names */

free((void*) meter_fg); /* if for some impossible reason above fails, continue on valiantly */

meter_fg = &(gtk_widget_get_style(widget)->text_aa[GTK_STATE_ACTIVE]); /* should never happen, but this would pick up color from existing gtk style w/o needing any addl color allocs */

}

else

gdk_color_alloc(gdk_colormap_get_system(), meter_fg);

}

gdk_gc_set_foreground(gc, meter_fg);

}

/* NPM: called out of level_meters_configure_event() at initialization to

pickup background color for level metering from --bg_color command-line

argument, or create default. */

static void levelmeters_init_bg(GtkWidget* widget, GdkGC *gc) {

if (meter_bg == NULL) { /* if --bg_color command-line argument not provided */

meter_bg = (GdkColor *)g_malloc(sizeof(GdkColor)); /* free()'d on exit() */

if (!gdk_color_parse("#304050", meter_bg)) { /* a dark background color */

free((void*) meter_bg); /* if for some impossible reason above fails, continue on valiantly */

meter_bg = &(gtk_widget_get_style(widget)->text_aa[GTK_STATE_PRELIGHT]); /* should never happen, but this would pick up color from existing gtk style w/o needing any addl color allocs */

}

else

gdk_color_alloc(gdk_colormap_get_system(), meter_bg);

}

gdk_gc_set_foreground(gc, meter_bg);

}

gint level_meters_configure_event(GtkWidget *widget, GdkEventConfigure *event) {

int idx = get_index(gtk_widget_get_name(widget));

GtkAllocation allocation;

gtk_widget_get_allocation(widget, &allocation);

if (pixmap[idx] != NULL)

gdk_pixmap_unref(pixmap[idx]);

pixmap[idx] = gdk_pixmap_new(gtk_widget_get_window(widget),

allocation.width,

allocation.height,

-1);

penWhiteLight[idx] = get_pen(idx, 0xffff, 0xffff, 0xffff);

penGreenLight[idx] = get_pen(idx, 0, 0xffff, 0);

/* NPM: Setup penForeground[idx] color for meters */

levelmeters_init_fg(widget, (penForeground[idx] = gdk_gc_new(pixmap[idx])));

/* NPM: Setup penBackground[idx] color for meters */

levelmeters_init_bg(widget, (penBackground[idx] = gdk_gc_new(pixmap[idx])));

penOrangeLight[idx] = get_pen(idx, 0xff11, 0x9911, 0);

peak_label_color = (GdkColor *)g_malloc(sizeof(GdkColor)); /* free()'d on exit() */

gdk_color_parse("red", peak_label_color);

gdk_color_alloc(gdk_colormap_get_system(), peak_label_color);

penRedLight[idx] = get_pen(idx, 0xffff, 0, 0);

gdk_draw_rectangle(pixmap[idx],

gtk_widget_get_style(widget)->black_gc,

TRUE,

0, 0,

allocation.width,

allocation.height);

/* NPM: ensure redraw_meters() below does a full refresh, per meter */

if (idx == 0) { /* "if stereo" -- special case for L/R output pair of digital mixer */

// g_print("level_meters_configure_event() for stereo\n");

peak_levels[IDX_LMIX] = 0;

peak_levels[IDX_RMIX] = 0;

previous_levels[IDX_LMIX] = 0;

previous_levels[IDX_RMIX] = 0;

peak_changed[IDX_LMIX] = RESET;

peak_changed[IDX_RMIX] = RESET;

}

else {

// g_print("level_meters_configure_event() for %i\n", idx);

peak_levels[idx-1] = 0;

previous_levels[idx-1] = 0;

peak_changed[idx-1] = RESET;

}

// g_print("configure: %i:%i\n", allocation.width, allocation.height);

redraw_meters(idx, allocation.width, allocation.height, 0, 0);

return TRUE;

}

gint level_meters_expose_event(GtkWidget *widget, GdkEventExpose *event) {

int idx = get_index(gtk_widget_get_name(widget));

int l1, l2;

GtkAllocation allocation;

gtk_widget_get_allocation(widget, &allocation);

get_levels(idx, &l1, &l2);

redraw_meters(idx, allocation.width, allocation.height, l1, l2);

gdk_draw_pixmap(gtk_widget_get_window(widget),

gtk_widget_get_style(widget)->black_gc,

pixmap[idx],

event->area.x, event->area.y,

event->area.x, event->area.y,

event->area.width, event->area.height);

return FALSE;

}

gint level_meters_timeout_callback(gpointer data) {

GtkWidget *widget;

int idx, l1, l2;

GtkAllocation allocation;

update_peak_switch();

for (idx = 0; idx <= pcm_output_channels; idx++) {

get_levels(idx, &l1, &l2);

widget = idx == 0 ? mixer_mix_drawing : mixer_drawing[idx-1];

if (gtk_widget_get_visible(widget) && (pixmap[idx] != NULL)) {

gtk_widget_get_allocation(widget, &allocation);

redraw_meters(idx, allocation.width, allocation.height, l1, l2);

gdk_draw_pixmap(gtk_widget_get_window(widget),

gtk_widget_get_style(widget)->black_gc,

pixmap[idx],

0, 0,

0, 0,

allocation.width, allocation.height);

}

/* NPM: both cases below are special-case hack to get

"Analog Volume" PCM peak levels updating correctly,

should "Analog Volume" panel be selected before "Monitor

PCM outs" panel. In that situation,

"(gtk_widget_get_visible(widget) && (pixmap[idx] != NULL))"

fails as level_meters_configure_event() hasn't been

called yet (it gets called when user selects "Monitor

PCM outs" panel).

*/

else if ((idx != 0)

&& ((idx-1) < envy_dac_volumes())

&& (peak_changed[idx-1] == TRUE)) {

draw_peak_labels(idx-1, FALSE, l1, l2);

peak_changed[idx-1] = FALSE;

// g_print("NPM PCM outputs hack calling draw_peak_labels(%i): %i\n", idx-1, l1);

}

/* NPM: make it work, even after user does a RESET, while

in "Analog Volume" panel, before "Monitor PCM outs"

created/configured */

else if ((idx != 0)

&& ((idx-1) < envy_dac_volumes())

&& (peak_changed[idx-1] == RESET)) { /* note that get_levels() never retrieved l1, l2 due to unfulfilled RESET */

GtkWidget* lbl;

/* NPM: Reset colors of peak labels for DACs in "Analog Volume" panel */

if ((idx-1) < envy_dac_volumes() /* index 0-8 corresponds to one of the eight DAC's */

&& ((idx-1) < MAX_OUTPUT_CHANNELS) /* make sure within bounds of dac_peak_label[] */

&& (lbl = dac_peak_label[idx-1]) != NULL)

gtk_widget_modify_fg(lbl, GTK_STATE_NORMAL, NULL); /* reset color */

/* NPM: Reset colors of peak labels for ADCs in "Analog Volume" panel */

else if (((idx-1) >= (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)) /* ADC channels begin at 11 = MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS */

&& ((idx-1) < (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS + envy_adc_volumes())) /* ADC channels end at 19 */

&& (((idx-1) - (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)) < MAX_INPUT_CHANNELS) /* make sure within bounds of adc_peak_label[] */

&& (lbl = adc_peak_label[(idx-1) - (MAX_PCM_OUTPUT_CHANNELS+MAX_SPDIF_CHANNELS)]) != NULL)

gtk_widget_modify_fg(lbl, GTK_STATE_NORMAL, NULL); /* reset color */

peak_changed[idx-1] = FALSE; /* hack -- force get_levels() to retrieve levels despite RESET */

get_levels(idx, &l1, &l2);

draw_peak_labels(idx-1, FALSE, l1, l2);

// g_print("NPM PCM outputs RESET hack calling draw_peak_labels(%i): %i\n", idx-1, l1);

}

}

if (view_spdif_playback) {

for (idx = MAX_PCM_OUTPUT_CHANNELS + 1; idx <= MAX_OUTPUT_CHANNELS + spdif_channels; idx++) {

get_levels(idx, &l1, &l2);

widget = idx == 0 ? mixer_mix_drawing : mixer_drawing[idx-1];

if (gtk_widget_get_visible(widget) && (pixmap[idx] != NULL)) {

gtk_widget_get_allocation(widget, &allocation);

redraw_meters(idx, allocation.width, allocation.height, l1, l2);

gdk_draw_pixmap(gtk_widget_get_window(widget),

gtk_widget_get_style(widget)->black_gc,

pixmap[idx],

0, 0,

0, 0,

allocation.width, allocation.height);

}

}

}

for (idx = MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + 1; idx <= input_channels + MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS; idx++) {

get_levels(idx, &l1, &l2);

widget = idx == 0 ? mixer_mix_drawing : mixer_drawing[idx-1];

if (gtk_widget_get_visible(widget) && (pixmap[idx] != NULL)) {

gtk_widget_get_allocation(widget, &allocation);

redraw_meters(idx, allocation.width, allocation.height, l1, l2);

gdk_draw_pixmap(gtk_widget_get_window(widget),

gtk_widget_get_style(widget)->black_gc,

pixmap[idx],

0, 0,

0, 0,

allocation.width, allocation.height);

}

}

for (idx = MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + MAX_INPUT_CHANNELS + 1; \

idx <= spdif_channels + MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + MAX_INPUT_CHANNELS; idx++) {

get_levels(idx, &l1, &l2);

widget = idx == 0 ? mixer_mix_drawing : mixer_drawing[idx-1];

if (gtk_widget_get_visible(widget) && (pixmap[idx] != NULL)) {

gtk_widget_get_allocation(widget, &allocation);

redraw_meters(idx, allocation.width, allocation.height, l1, l2);

gdk_draw_pixmap(gtk_widget_get_window(widget),

gtk_widget_get_style(widget)->black_gc,

pixmap[idx],

0, 0,

0, 0,

allocation.width, allocation.height);

}

}

return TRUE;

}

/* NPM fixed lack of implementation ( https://bugzilla.redhat.com/show_bug.cgi?id=602903 )*/

void level_meters_reset_peaks(GtkButton *button, gpointer data) {

int i;

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

peak_levels[i] = 0;

previous_levels[i] = 0;

peak_changed[i] = RESET;

}

level_meters_timeout_callback((gpointer) data);

}

void level_meters_init(void) {

int err;

snd_ctl_elem_value_malloc(&peaks);

snd_ctl_elem_value_set_interface(peaks, SND_CTL_ELEM_IFACE_PCM);

snd_ctl_elem_value_set_name(peaks, "Multi Track Peak");

if ((err = snd_ctl_elem_read(ctl, peaks)) < 0)

/* older ALSA driver, using MIXER type */

snd_ctl_elem_value_set_interface(peaks,

SND_CTL_ELEM_IFACE_MIXER);

}

void level_meters_postinit(void) {

level_meters_timeout_callback(NULL);

}