main.c

   1 /*
   2  * This file is part of the sigrok-gtk project.
   3  *
   4  * Copyright (C) 2011 Gareth McMullin <gareth@blacksphere.co.nz>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <libsigrok/libsigrok.h>
  21 #include <gtk/gtk.h>
  22
  23 #include <errno.h>
  24 #include <stdlib.h>
  25 #include <sys/stat.h>
  26
  27 #include "sigrok-gtk.h"
  28
  29 GtkWidget *sigview;
  30
  31 static const char *colours[8] = {
  32         "black", "brown", "red", "orange",
  33         "gold", "darkgreen", "blue", "magenta",
  34 };
  35
  36 static void datafeed_in(const struct sr_dev_inst *sdi,
  37                         const struct sr_datafeed_packet *packet)
  38 {
  39         static int logic_probelist[SR_MAX_NUM_PROBES + 1] = { -1 };
  40         static int unitsize = 0;
  41         const struct sr_probe *probe;
  42         const struct sr_datafeed_logic *logic = NULL;
  43         const struct sr_datafeed_meta_logic *meta_logic;
  44         int num_enabled_probes, sample_size, i;
  45         uint64_t filter_out_len;
  46         uint8_t *filter_out;
  47         GArray *data;
  48
  49         switch (packet->type) {
  50         case SR_DF_HEADER:
  51                 g_message("fe: Received SR_DF_HEADER");
  52                 break;
  53         case SR_DF_END:
  54                 sigview_zoom(sigview, 1, 0);
  55                 g_message("fe: Received SR_DF_END");
  56                 sr_session_stop();
  57                 break;
  58         case SR_DF_TRIGGER:
  59                 g_message("fe: received SR_DF_TRIGGER");
  60                 break;
  61         case SR_DF_META_LOGIC:
  62                 g_message("fe: received SR_DF_META_LOGIC");
  63                 meta_logic = (const struct sr_datafeed_meta_logic *)packet->payload;
  64                 num_enabled_probes = 0;
  65                 gtk_list_store_clear(siglist);
  66                 for (i = 0; i < meta_logic->num_probes; i++) {
  67                         probe = (const struct sr_probe *)g_slist_nth_data(sdi->probes, i);
  68                         if (probe->enabled) {
  69                                 GtkTreeIter iter;
  70                                 logic_probelist[num_enabled_probes++] = probe->index;
  71                                 gtk_list_store_append(siglist, &iter);
  72                                 gtk_list_store_set(siglist, &iter,
  73                                                 0, probe->name,
  74                                                 1, colours[(num_enabled_probes - 1) & 7],
  75                                                 2, num_enabled_probes - 1,
  76                                                 -1);
  77                         }
  78                 }
  79                 logic_probelist[num_enabled_probes] = -1;
  80                 /* How many bytes we need to store num_enabled_probes bits */
  81                 unitsize = (num_enabled_probes + 7) / 8;
  82                 data = g_array_new(FALSE, FALSE, unitsize);
  83                 g_object_set_data(G_OBJECT(siglist), "sampledata", data);
  84                 break;
  85         case SR_DF_LOGIC:
  86                 logic = (const struct sr_datafeed_logic *)packet->payload;
  87                 sample_size = logic->unitsize;
  88                 g_message("fe: received SR_DF_LOGIC, %"PRIu64" bytes", logic->length);
  89
  90                 if (!logic)
  91                         break;
  92
  93                 if (sr_filter_probes(sample_size, unitsize, logic_probelist,
  94                                            logic->data, logic->length,
  95                                            &filter_out, &filter_out_len) != SR_OK)
  96                         break;
  97
  98                 data = g_object_get_data(G_OBJECT(siglist), "sampledata");
  99                 g_return_if_fail(data != NULL);
 100
 101                 g_array_append_vals(data, filter_out, filter_out_len/unitsize);
 102
 103                 g_free(filter_out);
 104                 break;
 105         default:
 106                 g_message("fw: received unknown packet type %d", packet->type);
 107                 break;
 108         }
 109 }
 110
 111 void load_input_file(GtkWindow *parent, const gchar *file)
 112 {
 113         if (sr_session_load(file) == SR_OK) {
 114                 /* sigrok session file */
 115                 sr_session_datafeed_callback_add(datafeed_in);
 116                 sr_session_start();
 117                 sr_session_run();
 118                 sr_session_stop();
 119         }
 120
 121         /* Create a new session and programatically emit changed signal from
 122          * the device selection combo box to reselect the device.
 123          */
 124         sr_session_new();
 125         sr_session_datafeed_callback_add(datafeed_in);
 126         g_signal_emit_by_name(g_object_get_data(G_OBJECT(parent), "devcombo"),
 127                         "changed");
 128 }
 129
 130 int main(int argc, char **argv)
 131 {
 132         GtkWindow *window;
 133         GtkWidget *vbox, *vpaned, *log;
 134         struct sr_context *sr_ctx;
 135         struct sr_dev_driver **drivers, **driver;
 136
 137         gtk_init(&argc, &argv);
 138         icons_register();
 139
 140         sr_init(&sr_ctx);
 141
 142         /* Initialize all libsigrok drivers. */
 143         drivers = sr_driver_list();
 144         for (driver = drivers; *driver; driver++) {
 145                 if (sr_driver_init(sr_ctx, *driver) != SR_OK) {
 146                         g_error("Failed to initialize driver %s.",
 147                                 (*driver)->name);
 148                         exit(1); // FIXME?
 149                 }
 150         }
 151
 152         sr_session_new();
 153         sr_session_datafeed_callback_add(datafeed_in);
 154
 155         window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
 156         gtk_window_set_icon_name(window, "sigrok-logo");
 157         gtk_window_set_title(window, "sigrok-gtk");
 158         gtk_window_set_default_size(window, 600, 400);
 159
 160         g_signal_connect(window, "destroy", gtk_main_quit, NULL);
 161
 162         vbox = gtk_vbox_new(FALSE, 0);
 163         vpaned = gtk_vpaned_new();
 164
 165         gtk_box_pack_start(GTK_BOX(vbox), toolbar_init(window), FALSE, FALSE, 0);
 166         gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0);
 167         log = log_init();
 168         gtk_widget_set_no_show_all(log, TRUE);
 169         g_object_set_data(G_OBJECT(window), "logview", log);
 170         gtk_paned_add2(GTK_PANED(vpaned), log);
 171         sigview = sigview_init();
 172         g_object_set_data(G_OBJECT(window), "sigview", sigview);
 173         gtk_paned_pack1(GTK_PANED(vpaned), sigview, TRUE, FALSE);
 174
 175         gtk_container_add(GTK_CONTAINER(window), vbox);
 176         gtk_widget_show_all(GTK_WIDGET(window));
 177
 178         sr_log_loglevel_set(SR_LOG_ERR);
 179
 180         gtk_main();
 181
 182         sr_session_destroy();
 183         gtk_exit(0);
 184
 185         return 0;
 186 }
 187