Dirk Kalis <dirk.kalis@rs2.de>

i have an useability patch for envy24control.
Jaroslav
First try to fix ADC Volume range for AK4529...

diff --git a/envy24control/envy24control.c b/envy24control/envy24control.c
index 936585a98f29682801bd2133c67e21363788d56e..a4b0e92c63eea70d735319d4a7b457616ef5ebe6 100644 (file)
--- a/envy24control/envy24control.c
+++ b/envy24control/envy24control.c
@@ -46,6 +46,7 @@ GtkWidget *hw_master_clock_xtal_96000;
 GtkWidget *hw_master_clock_spdif_radio;
 GtkWidget *hw_master_clock_word_radio;
 GtkWidget *hw_master_clock_status_label;
+GtkWidget *hw_master_clock_actual_rate_label;
 
 GtkWidget *hw_clock_state_label;
 GtkWidget *hw_clock_state_locked;
@@ -127,7 +128,7 @@ static void create_mixer_frame(GtkWidget *fixed, int stream)
        gtk_widget_show(frame);
        gtk_fixed_put(GTK_FIXED(fixed), frame, 2 + (stream - 1) * 102, 2);
        gtk_widget_set_uposition(frame, 2 + (stream - 1) * 102, 2);
-       gtk_widget_set_usize(frame, 98, 288);
+       gtk_widget_set_usize(frame, 98, 338);
        gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
 
        fixed1 = gtk_fixed_new();
@@ -141,7 +142,7 @@ static void create_mixer_frame(GtkWidget *fixed, int stream)
         gtk_widget_show(vscale);
        gtk_fixed_put(GTK_FIXED(fixed1), vscale, 8, 8);
        gtk_widget_set_uposition(vscale, 7, 8);
-       gtk_widget_set_usize(vscale, 18, 168);  
+       gtk_widget_set_usize(vscale, 18, 218);  
        gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
        gtk_scale_set_digits(GTK_SCALE(vscale), 0);
        gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
@@ -159,7 +160,7 @@ static void create_mixer_frame(GtkWidget *fixed, int stream)
        gtk_widget_set_events(drawing, GDK_EXPOSURE_MASK);
        gtk_fixed_put(GTK_FIXED(fixed1), drawing, 24, 9);
        gtk_widget_set_uposition(drawing, 24, 9);
-       gtk_widget_set_usize(drawing, 45, 152); 
+       gtk_widget_set_usize(drawing, 45, 202); 
 
        adj = gtk_adjustment_new(96, 0, 96, 1, 16, 0);
        mixer_adj[stream-1][1] = adj;
@@ -168,7 +169,7 @@ static void create_mixer_frame(GtkWidget *fixed, int stream)
         gtk_widget_show(vscale);
        gtk_fixed_put(GTK_FIXED(fixed1), vscale, 70, 8);
        gtk_widget_set_uposition(vscale, 69, 8);
-       gtk_widget_set_usize(vscale, 18, 168);  
+       gtk_widget_set_usize(vscale, 18, 218);  
        gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
        gtk_scale_set_digits(GTK_SCALE(vscale), 0);
        gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
@@ -176,21 +177,21 @@ static void create_mixer_frame(GtkWidget *fixed, int stream)
 
         label = gtk_label_new("Left");
         gtk_widget_show(label);
-       gtk_fixed_put(GTK_FIXED(fixed1), label, 0, 182);
-       gtk_widget_set_uposition(label, 0, 182);
+       gtk_fixed_put(GTK_FIXED(fixed1), label, 0, 232);
+       gtk_widget_set_uposition(label, 0, 232);
        gtk_widget_set_usize(label, 41, 16);    
 
         label = gtk_label_new("Right");
         gtk_widget_show(label);
-       gtk_fixed_put(GTK_FIXED(fixed1), label, 45, 182);
-       gtk_widget_set_uposition(label, 45, 182);
+       gtk_fixed_put(GTK_FIXED(fixed1), label, 45, 232);
+       gtk_widget_set_uposition(label, 45, 232);
        gtk_widget_set_usize(label, 41, 16);
 
        toggle = gtk_toggle_button_new_with_label("Mute");
        mixer_mute_toggle[stream-1][0] = toggle;
        gtk_widget_show(toggle);
-       gtk_fixed_put(GTK_FIXED(fixed1), toggle, 8, 202);
-       gtk_widget_set_uposition(toggle, 8, 202);
+       gtk_fixed_put(GTK_FIXED(fixed1), toggle, 8, 252);
+       gtk_widget_set_uposition(toggle, 8, 252);
        gtk_widget_set_usize(toggle, 36, 22);   
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);
        gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
@@ -199,8 +200,8 @@ static void create_mixer_frame(GtkWidget *fixed, int stream)
        toggle = gtk_toggle_button_new_with_label("Mute");
        mixer_mute_toggle[stream-1][1] = toggle;
        gtk_widget_show(toggle);
-       gtk_fixed_put(GTK_FIXED(fixed1), toggle, 48, 202);
-       gtk_widget_set_uposition(toggle, 48, 202);
+       gtk_fixed_put(GTK_FIXED(fixed1), toggle, 48, 252);
+       gtk_widget_set_uposition(toggle, 48, 252);
        gtk_widget_set_usize(toggle, 36, 22);   
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);
        gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
@@ -208,15 +209,15 @@ static void create_mixer_frame(GtkWidget *fixed, int stream)
        
        hseparator = gtk_hseparator_new();
        gtk_widget_show(hseparator);
-       gtk_fixed_put(GTK_FIXED(fixed1), hseparator, 0, 222);
-       gtk_widget_set_uposition(hseparator, 0, 222);
+       gtk_fixed_put(GTK_FIXED(fixed1), hseparator, 0, 272);
+       gtk_widget_set_uposition(hseparator, 0, 272);
        gtk_widget_set_usize(hseparator, 92, 16);
 
        toggle = gtk_toggle_button_new_with_label("L/R Gang");
        mixer_stereo_toggle[stream-1] = toggle;
        gtk_widget_show(toggle);
-       gtk_fixed_put(GTK_FIXED(fixed1), toggle, 3, 235);
-       gtk_widget_set_uposition(toggle, 3, 235);
+       gtk_fixed_put(GTK_FIXED(fixed1), toggle, 3, 285);
+       gtk_widget_set_uposition(toggle, 3, 285);
        gtk_widget_set_usize(toggle, 85, 32);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);
 }
@@ -265,31 +266,31 @@ static void create_mixer(GtkWidget *main, GtkWidget *notebook, int page)
        gtk_widget_show(drawing);
        gtk_fixed_put(GTK_FIXED(fixed), drawing, 4, 2);
        gtk_widget_set_uposition(drawing, 4, 2);
-       gtk_widget_set_usize(drawing, 98, 226); 
+       gtk_widget_set_usize(drawing, 98, 276); 
 
         label = gtk_label_new("Left");
         gtk_widget_show(label);
-       gtk_fixed_put(GTK_FIXED(fixed), label, 10, 232);
-       gtk_widget_set_uposition(label, 10, 232);
+       gtk_fixed_put(GTK_FIXED(fixed), label, 10, 282);
+       gtk_widget_set_uposition(label, 10, 282);
        gtk_widget_set_usize(label, 34, 16);    
 
         label = gtk_label_new("Right");
         gtk_widget_show(label);
-       gtk_fixed_put(GTK_FIXED(fixed), label, 60, 232);
-       gtk_widget_set_uposition(label, 60, 232);
+       gtk_fixed_put(GTK_FIXED(fixed), label, 60, 282);
+       gtk_widget_set_uposition(label, 60, 282);
        gtk_widget_set_usize(label, 34, 16);
 
        hseparator = gtk_hseparator_new();
        gtk_widget_show(hseparator);
-       gtk_fixed_put(GTK_FIXED(fixed), hseparator, 0, 244);
-       gtk_widget_set_uposition(hseparator, 0, 244);
+       gtk_fixed_put(GTK_FIXED(fixed), hseparator, 0, 294);
+       gtk_widget_set_uposition(hseparator, 0, 294);
        gtk_widget_set_usize(hseparator, 104, 16);
 
        button = gtk_button_new_with_label("Reset Peaks");
        mixer_clear_peaks_button = button;
        gtk_widget_show(button);
-       gtk_fixed_put(GTK_FIXED(fixed), button, 3, 256);
-       gtk_widget_set_uposition(button, 3, 256);
+       gtk_fixed_put(GTK_FIXED(fixed), button, 3, 306);
+       gtk_widget_set_uposition(button, 3, 306);
        gtk_widget_set_usize(button, 100, 35);  
        gtk_signal_connect(GTK_OBJECT(button), "clicked",
                           GTK_SIGNAL_FUNC(level_meters_reset_peaks), NULL);
@@ -349,7 +350,7 @@ static void create_router_frame(GtkWidget *fixed, int stream, int pos)
        gtk_widget_show(frame);
        gtk_fixed_put(GTK_FIXED(fixed), frame, 2 + pos * 130, 2);
        gtk_widget_set_uposition(frame, 2 + pos * 130, 2);
-       gtk_widget_set_usize(frame, 125, 290);
+       gtk_widget_set_usize(frame, 125, 340);
 
        fixed1 = gtk_fixed_new();
        gtk_widget_show(fixed1);
@@ -394,8 +395,8 @@ static void create_router_frame(GtkWidget *fixed, int stream, int pos)
                router_radio[stream-1][2+idx] = radio;
                group = gtk_radio_button_group(GTK_RADIO_BUTTON(radio));
                gtk_widget_show(radio);
-               gtk_fixed_put(GTK_FIXED(fixed1), radio, 0, 64 + (idx * 20));
-               gtk_widget_set_uposition(radio, 0, 64 + (idx * 20));
+               gtk_fixed_put(GTK_FIXED(fixed1), radio, 0, 64 + (idx * 25));
+               gtk_widget_set_uposition(radio, 0, 64 + (idx * 25));
                gtk_widget_set_usize(radio, 120, 24);
                gtk_signal_connect(GTK_OBJECT(radio), "toggled",
                                   (GtkSignalFunc)patchbay_toggled, (gpointer)((stream << 16) + 2 + idx));
@@ -588,6 +589,43 @@ static void create_rate_state(GtkWidget *fixed)
 
 }
 
+static void create_actual_rate(GtkWidget *fixed)
+{
+       GtkWidget *frame;
+       GtkWidget *fixed1;
+       GtkWidget *viewport;
+       GtkWidget *label;
+       GtkWidget *fixed2;
+
+       frame = gtk_frame_new("Actual Rate");
+       gtk_widget_show(frame);
+       gtk_fixed_put(GTK_FIXED(fixed), frame, 8, 251);
+       gtk_widget_set_uposition(frame, 8, 251);
+       gtk_widget_set_usize(frame, 135, 45);
+
+       fixed1 = gtk_fixed_new();
+       gtk_widget_show(fixed1);
+       gtk_container_add(GTK_CONTAINER(frame), fixed1);        
+
+       viewport = gtk_viewport_new(NULL, NULL);
+       gtk_widget_show(viewport);
+       gtk_fixed_put(GTK_FIXED(fixed1), viewport, 9, 0);
+       gtk_widget_set_uposition(viewport, 9, 0);
+       gtk_widget_set_usize(viewport, 90, 21);
+
+       fixed2 = gtk_fixed_new();
+       gtk_widget_show(fixed2);
+       gtk_container_add(GTK_CONTAINER(viewport), fixed2);     
+
+        label = gtk_label_new("");
+        hw_master_clock_actual_rate_label = label;
+        gtk_widget_show(label);
+       gtk_fixed_put(GTK_FIXED(fixed2), label, 0, 1);
+       gtk_widget_set_uposition(label, 0, 1);
+       gtk_widget_set_usize(label, 86, 16);
+
+}
+
 static void create_volume_change(GtkWidget *fixed)
 {
        GtkWidget *frame;
@@ -598,8 +636,8 @@ static void create_volume_change(GtkWidget *fixed)
 
        frame = gtk_frame_new("Volume Change");
        gtk_widget_show(frame);
-       gtk_fixed_put(GTK_FIXED(fixed), frame, 8, 250);
-       gtk_widget_set_uposition(frame, 8, 250);
+       gtk_fixed_put(GTK_FIXED(fixed), frame, 8, 300);
+       gtk_widget_set_uposition(frame, 8, 300);
        gtk_widget_set_usize(frame, 135, 58);
 
        fixed1 = gtk_fixed_new();
@@ -978,7 +1016,7 @@ static void create_spdif_output_settings(GtkWidget *fixed)
        gtk_widget_show(frame);
        gtk_fixed_put(GTK_FIXED(fixed), frame, 150, 8);
        gtk_widget_set_uposition(frame, 150, 8);
-       gtk_widget_set_usize(frame, 580, 300);
+       gtk_widget_set_usize(frame, 580, 350);
 
        fixed1 = gtk_fixed_new();
        gtk_widget_show(fixed1);
@@ -1009,7 +1047,7 @@ static void create_spdif_output_settings(GtkWidget *fixed)
        gtk_widget_show(notebook);
        gtk_fixed_put(GTK_FIXED(fixed1), notebook, 5, 31);
        gtk_widget_set_uposition(notebook, 5, 31);
-       gtk_widget_set_usize(notebook, 565, 240);
+       gtk_widget_set_usize(notebook, 565, 290);
 
        create_spdif_output_settings_profi(notebook, 0);
        create_spdif_output_settings_consumer(notebook, 1);
@@ -1074,6 +1112,7 @@ static void create_hardware(GtkWidget *main, GtkWidget *notebook, int page)
 
        create_master_clock(fixed);
        create_rate_state(fixed);
+       create_actual_rate(fixed);
        create_volume_change(fixed);
        create_spdif_output_settings(fixed);
        create_spdif_input_select(fixed);
@@ -1153,19 +1192,19 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
                gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
                gtk_fixed_put(GTK_FIXED(fixed), frame, 2 + i * 120, 2);
                gtk_widget_set_uposition(frame, 2 + i * 120, 2);
-               gtk_widget_set_usize(frame, 115, 288);
+               gtk_widget_set_usize(frame, 115, 338);
 
                fixed1 = gtk_fixed_new();
                gtk_widget_show(fixed1);
                gtk_container_add(GTK_CONTAINER(frame), fixed1);        
 
-               adj = gtk_adjustment_new(0, -127, 0, 1, 16, 0);
+               adj = gtk_adjustment_new(0, -(envy_dac_max()), 0, 1, 16, 0);
                av_dac_volume_adj[i] = adj;
                vscale = gtk_vscale_new(GTK_ADJUSTMENT(adj));
                gtk_scale_set_draw_value(GTK_SCALE(vscale), FALSE);
                gtk_widget_show(vscale);
                gtk_fixed_put(GTK_FIXED(fixed1), vscale, 26, 2);
-               gtk_widget_set_usize(vscale, 66, 180);
+               gtk_widget_set_usize(vscale, 66, 230);
                gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
                gtk_scale_set_digits(GTK_SCALE(vscale), 0);
                gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
@@ -1174,8 +1213,8 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
                label = gtk_label_new("100 (-000dB)");
                av_dac_volume_label[i] = (GtkLabel *)label;
                gtk_widget_show(label);
-               gtk_fixed_put(GTK_FIXED(fixed1), label, 4, 182);
-               gtk_widget_set_uposition(label, 4, 182);
+               gtk_fixed_put(GTK_FIXED(fixed1), label, 4, 232);
+               gtk_widget_set_uposition(label, 4, 232);
                gtk_widget_set_usize(label, 105, 16);
 
                if (i >= envy_dac_senses())
@@ -1202,7 +1241,7 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
                gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
                gtk_fixed_put(GTK_FIXED(fixed), frame, 2 + (i + envy_dac_volumes()) * 120, 2);
                gtk_widget_set_uposition(frame, 2 + (i + envy_dac_volumes()) * 120, 2);
-               gtk_widget_set_usize(frame, 115, 288);
+               gtk_widget_set_usize(frame, 115, 338);
 
                fixed1 = gtk_fixed_new();
                gtk_widget_show(fixed1);
@@ -1214,7 +1253,7 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
                gtk_scale_set_draw_value(GTK_SCALE(vscale), FALSE);
                gtk_widget_show(vscale);
                gtk_fixed_put(GTK_FIXED(fixed1), vscale, 26, 2);
-               gtk_widget_set_usize(vscale, 66, 180);
+               gtk_widget_set_usize(vscale, 66, 230);
                gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
                gtk_scale_set_digits(GTK_SCALE(vscale), 0);
                gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
@@ -1223,8 +1262,8 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
                label = gtk_label_new("100 (-000dB)");
                av_adc_volume_label[i] = (GtkLabel *)label;
                gtk_widget_show(label);
-               gtk_fixed_put(GTK_FIXED(fixed1), label, 4, 182);
-               gtk_widget_set_uposition(label, 4, 182);
+               gtk_fixed_put(GTK_FIXED(fixed1), label, 4, 232);
+               gtk_widget_set_uposition(label, 4, 232);
                gtk_widget_set_usize(label, 105, 16);
 
                if (i >= envy_adc_senses())
@@ -1251,7 +1290,7 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
                gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
                gtk_fixed_put(GTK_FIXED(fixed), frame, 2 + (i + envy_dac_volumes() + envy_adc_volumes()) * 120, 2);
                gtk_widget_set_uposition(frame, 2 + (i + envy_dac_volumes() + envy_adc_volumes()) * 120, 2);
-               gtk_widget_set_usize(frame, 115, 288);
+               gtk_widget_set_usize(frame, 115, 338);
 
                fixed1 = gtk_fixed_new();
                gtk_widget_show(fixed1);
@@ -1263,7 +1302,7 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
                gtk_scale_set_draw_value(GTK_SCALE(vscale), FALSE);
                gtk_widget_show(vscale);
                gtk_fixed_put(GTK_FIXED(fixed1), vscale, 26, 2);
-               gtk_widget_set_usize(vscale, 66, 180);
+               gtk_widget_set_usize(vscale, 66, 230);
                gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);
                gtk_scale_set_digits(GTK_SCALE(vscale), 0);
                gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
@@ -1272,8 +1311,8 @@ static void create_analog_volume(GtkWidget *main, GtkWidget *notebook, int page)
                label = gtk_label_new("100 (-000dB)");
                av_ipga_volume_label[i] = (GtkLabel *)label;
                gtk_widget_show(label);
-               gtk_fixed_put(GTK_FIXED(fixed1), label, 4, 182);
-               gtk_widget_set_uposition(label, 4, 182);
+               gtk_fixed_put(GTK_FIXED(fixed1), label, 4, 232);
+               gtk_widget_set_uposition(label, 4, 232);
                gtk_widget_set_usize(label, 105, 16);
        }
 }
@@ -1363,7 +1402,7 @@ int main(int argc, char **argv)
         gtk_signal_connect(GTK_OBJECT (window), "delete_event", 
                            (GtkSignalFunc) gtk_main_quit, NULL);
         signal(SIGINT, (void *)gtk_main_quit);
-        gtk_widget_set_usize(window, 740, 350);
+        gtk_widget_set_usize(window, 740, 400);
         gtk_window_set_policy(GTK_WINDOW (window), FALSE, TRUE, FALSE);
         gtk_widget_realize(window);
 
@@ -1394,6 +1433,7 @@ int main(int argc, char **argv)
        }
        gtk_timeout_add(40, level_meters_timeout_callback, NULL);
        gtk_timeout_add(100, master_clock_status_timeout_callback, NULL);
+       gtk_timeout_add(100, internal_clock_status_timeout_callback, NULL);
 
        level_meters_postinit();
        mixer_postinit();

diff --git a/envy24control/envy24control.h b/envy24control/envy24control.h
index ef3a4fcab2faf4d73bfe49420e522c30d1c2f711..ae15b3111ae90705ad72ecc9a00fff5ccb87f343 100644 (file)
--- a/envy24control/envy24control.h
+++ b/envy24control/envy24control.h
@@ -68,6 +68,7 @@ extern GtkWidget *hw_master_clock_xtal_96000;
 extern GtkWidget *hw_master_clock_spdif_radio;
 extern GtkWidget *hw_master_clock_word_radio;
 extern GtkWidget *hw_master_clock_status_label;
+extern GtkWidget *hw_master_clock_actual_rate_label;
 
 extern GtkWidget *hw_rate_locking_check;
 extern GtkWidget *hw_rate_reset_check;
@@ -137,6 +138,7 @@ void patchbay_postinit(void);
 
 void master_clock_update(void);
 gint master_clock_status_timeout_callback(gpointer data);
+gint internal_clock_status_timeout_callback(gpointer data);
 void internal_clock_toggled(GtkWidget *togglebutton, gpointer data);
 void rate_locking_update(void);
 void rate_locking_toggled(GtkWidget *togglebutton, gpointer data);
@@ -160,6 +162,7 @@ void hardware_postinit(void);
 void analog_volume_init(void);
 void analog_volume_postinit(void);
 int envy_dac_volumes(void);
+int envy_dac_max(void);
 int envy_adc_volumes(void);
 int envy_ipga_volumes(void);
 int envy_dac_senses(void);

diff --git a/envy24control/hardware.c b/envy24control/hardware.c
index 6e660b18554fdde7a0a59c4c7886aaf39114362a..c6417db24f5e51ed454ac1e892f94ece204af5b7 100644 (file)
--- a/envy24control/hardware.c
+++ b/envy24control/hardware.c
@@ -66,6 +66,7 @@ void master_clock_update(void)
                            break;
                }
        }
+       internal_clock_status_timeout_callback(NULL);
        master_clock_status_timeout_callback(NULL);
 }
 
@@ -117,6 +118,29 @@ void internal_clock_toggled(GtkWidget *togglebutton, gpointer data)
        }
 }
 
+static int is_rate_locked(void)
+{
+       int err;
+       
+       if ((err = snd_ctl_elem_read(ctl, rate_locking)) < 0)
+               g_print("Unable to read rate locking state: %s\n", snd_strerror(err));
+       return snd_ctl_elem_value_get_boolean(rate_locking, 0) ? 1 : 0;
+}
+
+static int is_rate_reset(void)
+{
+       int err;
+       
+       if ((err = snd_ctl_elem_read(ctl, rate_reset)) < 0)
+               g_print("Unable to read rate reset state: %s\n", snd_strerror(err));
+       return snd_ctl_elem_value_get_boolean(rate_reset, 0) ? 1 : 0;
+}
+
+static inline int is_update_needed(void)
+{
+       return (is_rate_locked() || !is_rate_reset());
+}
+
 gint master_clock_status_timeout_callback(gpointer data)
 {
        snd_ctl_elem_value_t *sw;
@@ -134,6 +158,64 @@ gint master_clock_status_timeout_callback(gpointer data)
        return TRUE;
 }
 
+gint internal_clock_status_timeout_callback(gpointer data)
+{
+       int err, rate, need_update;
+       char *label;
+       
+       if ((err = snd_ctl_elem_read(ctl, internal_clock)) < 0)
+               g_print("Unable to read Internal Clock state: %s\n", snd_strerror(err));
+       if (card_eeprom.subvendor == ICE1712_SUBDEVICE_DELTA1010) {
+               if ((err = snd_ctl_elem_read(ctl, word_clock_sync)) < 0)
+                       g_print("Unable to read word clock sync selection: %s\n", snd_strerror(err));
+       }
+       need_update = is_update_needed() ? 1 : 0;
+       if (snd_ctl_elem_value_get_enumerated(internal_clock, 0) == 13) {
+               if (snd_ctl_elem_value_get_boolean(word_clock_sync, 0)) {
+                       label = "Word Clock";
+               } else {
+                       label = "S/PDIF";
+               }
+       } else {
+//             toggle_set(hw_master_clock_xtal_radio, TRUE);
+               rate = snd_ctl_elem_value_get_enumerated(internal_clock, 0);
+//             g_print("Rate: %d need_update: %d\n", rate, need_update); // for debug
+               switch (rate) {
+               case 0: label = "8000"; break;
+               case 1: label = "9600"; break;
+               case 2: label = "11025"; break;
+               case 3: label = "12000"; break;
+               case 4: label = "16000"; break;
+               case 5: label = "22050";
+                       if (need_update)
+                       toggle_set(hw_master_clock_xtal_22050, TRUE); break;
+               case 6: label = "24000"; break;
+               case 7: label = "32000";
+                       if (need_update)
+                       toggle_set(hw_master_clock_xtal_32000, TRUE); break;
+               case 8: label = "44100";
+                       if (need_update)
+                       toggle_set(hw_master_clock_xtal_44100, TRUE); break;
+               case 9: label = "48000";
+                       if (need_update)
+                       toggle_set(hw_master_clock_xtal_48000, TRUE); break;
+               case 10: label = "64000"; break;
+               case 11: label = "88200";
+                       if (need_update)
+                       toggle_set(hw_master_clock_xtal_88200, TRUE); break;
+               case 12: label = "96000";
+                       if (need_update)
+                       toggle_set(hw_master_clock_xtal_96000, TRUE); break;
+               default:
+                           label = "ERROR";
+                           g_print("Error in rate: %d\n", rate);
+                           break;
+               }
+       }
+       gtk_label_set_text(GTK_LABEL(hw_master_clock_actual_rate_label), label);
+       return TRUE;
+}
+
 void rate_locking_update(void)
 {
        int err;
@@ -182,6 +264,7 @@ void rate_locking_toggled(GtkWidget *togglebutton, gpointer data)
        }
        if (!strcmp(what, "locked")) {
                rate_locking_set(1);
+               internal_clock_status_timeout_callback(NULL);
        } else {
                g_print("rate_locking_toggled: %s ???\n", what);
        }
@@ -193,6 +276,7 @@ void rate_reset_toggled(GtkWidget *togglebutton, gpointer data)
 
        if (!is_active(togglebutton)) {
                rate_reset_set(0);
+               internal_clock_status_timeout_callback(NULL);
                return;
        }
        if (!strcmp(what, "reset")) {

diff --git a/envy24control/volume.c b/envy24control/volume.c
index 471c7b6015deed6f133535f57dc323a789aef7b6..a06a7c215582fc344656b20457f39f4a73f02a7a 100644 (file)
--- a/envy24control/volume.c
+++ b/envy24control/volume.c
@@ -32,6 +32,7 @@
 #define ADC_SENSE_NAME "Input Sensitivity Switch"
 
 static int dac_volumes;
+static int dac_max = 127;
 static int adc_volumes;
 static int ipga_volumes;
 static int dac_senses;
@@ -46,6 +47,11 @@ int envy_dac_volumes(void)
        return dac_volumes;
 }
 
+int envy_dac_max(void)
+{
+       return dac_max;
+}
+
 int envy_adc_volumes(void)
 {
        return adc_volumes;
@@ -209,7 +215,7 @@ void dac_volume_adjust(GtkAdjustment *adj, gpointer data)
        snd_ctl_elem_value_set_name(val, DAC_VOLUME_NAME);
        snd_ctl_elem_value_set_index(val, idx);
        snd_ctl_elem_value_set_integer(val, 0, ival);
-       sprintf(text, "%03i %s", ival, ival == 127 ? "consumer" : (ival == 111 ? "-10dB" : ""));
+       sprintf(text, "%03i", ival);
        gtk_label_set_text(av_dac_volume_label[idx], text);
        if ((err = snd_ctl_elem_write(ctl, val)) < 0)
                g_print("Unable to write dac volume: %s\n", snd_strerror(err));
@@ -227,7 +233,7 @@ void adc_volume_adjust(GtkAdjustment *adj, gpointer data)
        snd_ctl_elem_value_set_name(val, ADC_VOLUME_NAME);
        snd_ctl_elem_value_set_index(val, idx);
        snd_ctl_elem_value_set_integer(val, 0, ival);
-       sprintf(text, "%03i %s", ival, ival == 127 ? "consumer" : (ival == 111 ? "-10dB" : ""));
+       sprintf(text, "%03i", ival);
        gtk_label_set_text(av_adc_volume_label[idx], text);
        if ((err = snd_ctl_elem_write(ctl, val)) < 0)
                g_print("Unable to write adc volume: %s\n", snd_strerror(err));
@@ -245,7 +251,7 @@ void ipga_volume_adjust(GtkAdjustment *adj, gpointer data)
        snd_ctl_elem_value_set_name(val, IPGA_VOLUME_NAME);
        snd_ctl_elem_value_set_index(val, idx);
        snd_ctl_elem_value_set_integer(val, 0, ival);
-       sprintf(text, "%03i %s", ival, ival == 0 ? "0dB" : (ival == 36 ? "+18dB" : ""));
+       sprintf(text, "%03i", ival);
        gtk_label_set_text(av_ipga_volume_label[idx], text);
        if ((err = snd_ctl_elem_write(ctl, val)) < 0)
                g_print("Unable to write ipga volume: %s\n", snd_strerror(err));
@@ -300,6 +306,7 @@ void analog_volume_init(void)
                snd_ctl_elem_info_set_index(info, i);
                if (snd_ctl_elem_info(ctl, info) < 0)
                        break;
+               dac_max = snd_ctl_elem_info_get_max(info);
        }
        dac_volumes = i;
        snd_ctl_elem_info_set_name(info, DAC_SENSE_NAME);