static int default_output_format = FALSE;
static char *output_format_param = NULL;
#ifdef HAVE_SRD
+static struct srd_session *srd_sess = NULL;
static GHashTable *pd_ann_visible = NULL;
+static GHashTable *pd_meta_visible = NULL;
+static GHashTable *pd_binary_visible = NULL;
#endif
static GByteArray *savebuf;
static gchar *opt_drv = NULL;
static gchar *opt_config = NULL;
static gchar *opt_probes = NULL;
+static gchar *opt_probe_group = NULL;
static gchar *opt_triggers = NULL;
static gchar *opt_pds = NULL;
#ifdef HAVE_SRD
static gchar *opt_pd_stack = NULL;
static gchar *opt_pd_annotations = NULL;
+static gchar *opt_pd_meta = NULL;
+static gchar *opt_pd_binary = NULL;
#endif
static gchar *opt_input_format = NULL;
static gchar *opt_output_format = NULL;
"Output format", NULL},
{"probes", 'p', 0, G_OPTION_ARG_STRING, &opt_probes,
"Probes to use", NULL},
+ {"probe-group", 'g', 0, G_OPTION_ARG_STRING, &opt_probe_group,
+ "Probe groups", NULL},
{"triggers", 't', 0, G_OPTION_ARG_STRING, &opt_triggers,
"Trigger configuration", NULL},
{"wait-trigger", 'w', 0, G_OPTION_ARG_NONE, &opt_wait_trigger,
"Protocol decoder stack", NULL},
{"protocol-decoder-annotations", 'A', 0, G_OPTION_ARG_STRING, &opt_pd_annotations,
"Protocol decoder annotation(s) to show", NULL},
+ {"protocol-decoder-meta", 'M', 0, G_OPTION_ARG_STRING, &opt_pd_meta,
+ "Protocol decoder meta output to show", NULL},
+ {"protocol-decoder-binary", 'B', 0, G_OPTION_ARG_STRING, &opt_pd_binary,
+ "Protocol decoder binary output to show", NULL},
#endif
{"scan", 0, 0, G_OPTION_ARG_NONE, &opt_scan_devs,
"Scan for devices", NULL},
return opts;
}
+static struct sr_probe_group *select_probe_group(struct sr_dev_inst *sdi)
+{
+ struct sr_probe_group *pg;
+ GSList *l;
+
+ if (!opt_probe_group)
+ return NULL;
+
+ if (!sdi->probe_groups) {
+ g_critical("This device does not have any probe groups.");
+ return NULL;
+ }
+
+ for (l = sdi->probe_groups; l; l = l->next) {
+ pg = l->data;
+ if (!strcasecmp(opt_probe_group, pg->name)) {
+ return pg;
+ }
+ }
+
+ return NULL;
+}
+
static void free_drvopts(struct sr_config *src)
{
g_variant_unref(src->data);
}
if (!driver) {
g_critical("Driver %s not found.", drvname);
+ g_hash_table_destroy(drvargs);
+ g_free(drvname);
return NULL;
}
g_free(drvname);
if (sr_driver_init(sr_ctx, driver) != SR_OK) {
g_critical("Failed to initialize driver.");
+ g_hash_table_destroy(drvargs);
return NULL;
}
drvopts = NULL;
return NULL;
}
}
- g_hash_table_destroy(drvargs);
+ g_hash_table_destroy(drvargs);
devices = sr_driver_scan(driver, drvopts);
g_slist_free_full(drvopts, (GDestroyNotify)free_drvopts);
} else {
outputs = sr_output_list();
for (i = 0; outputs[i]; i++)
printf(" %-20s %s\n", outputs[i]->id, outputs[i]->description);
+ printf(" %-20s %s\n", "sigrok", "Default file output format");
printf("\n");
#ifdef HAVE_SRD
s = g_string_sized_new(128);
g_string_assign(s, sdi->driver->name);
- if (sr_config_get(sdi->driver, SR_CONF_CONN, &gvar, sdi) == SR_OK) {
+ if (sr_config_get(sdi->driver, sdi, NULL, SR_CONF_CONN, &gvar) == SR_OK) {
g_string_append(s, ":conn=");
g_string_append(s, g_variant_get_string(gvar, NULL));
g_variant_unref(gvar);
{
struct sr_dev_inst *sdi;
const struct sr_config_info *srci;
- GSList *devices;
+ struct sr_probe *probe;
+ struct sr_probe_group *probe_group, *pg;
+ GSList *devices, *pgl, *prl;
GVariant *gvar_opts, *gvar_dict, *gvar_list, *gvar;
gsize num_opts, num_elements;
const uint64_t *uint64, p, q, low, high;
return;
}
- if ((sr_config_list(sdi->driver, SR_CONF_SCAN_OPTIONS, &gvar_opts,
- NULL) == SR_OK)) {
+ if ((sr_config_list(sdi->driver, NULL, NULL, SR_CONF_SCAN_OPTIONS,
+ &gvar_opts) == SR_OK)) {
opts = g_variant_get_fixed_array(gvar_opts, &num_elements,
sizeof(int32_t));
printf("Supported driver options:\n");
g_variant_unref(gvar_opts);
}
- if ((sr_config_list(sdi->driver, SR_CONF_DEVICE_OPTIONS, &gvar_opts,
- sdi) != SR_OK))
+ probe_group = select_probe_group(sdi);
+ if ((sr_config_list(sdi->driver, sdi, probe_group, SR_CONF_DEVICE_OPTIONS,
+ &gvar_opts)) != SR_OK)
/* Driver supports no device instance options. */
return;
- printf("Supported configuration options:\n");
+ if (sdi->probe_groups) {
+ printf("Probe groups:\n");
+ for (pgl = sdi->probe_groups; pgl; pgl = pgl->next) {
+ pg = pgl->data;
+ printf(" %s: channel%s", pg->name,
+ g_slist_length(pg->probes) > 1 ? "s" : "");
+ for (prl = pg->probes; prl; prl = prl->next) {
+ probe = prl->data;
+ printf(" %s", probe->name);
+ }
+ printf("\n");
+ }
+ }
+
+ printf("Supported configuration options");
+ if (sdi->probe_groups) {
+ if (!probe_group)
+ printf(" across all probe groups");
+ else
+ printf(" on probe group %s", probe_group->name);
+ }
+ printf(":\n");
opts = g_variant_get_fixed_array(gvar_opts, &num_opts, sizeof(int32_t));
for (o = 0; o < num_opts; o++) {
if (!(srci = sr_config_info_get(opts[o])))
continue;
if (srci->key == SR_CONF_TRIGGER_TYPE) {
- if (sr_config_list(sdi->driver, srci->key, &gvar,
- sdi) != SR_OK) {
+ if (sr_config_list(sdi->driver, sdi, probe_group, srci->key,
+ &gvar) != SR_OK) {
printf("\n");
continue;
}
} else if (srci->key == SR_CONF_PATTERN_MODE) {
/* Pattern generator modes */
printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, srci->key, &gvar,
- sdi) == SR_OK) {
+ if (sr_config_list(sdi->driver, sdi, probe_group, srci->key,
+ &gvar) == SR_OK) {
printf(" - supported patterns:\n");
stropts = g_variant_get_strv(gvar, &num_elements);
for (i = 0; i < num_elements; i++)
} else if (srci->key == SR_CONF_SAMPLERATE) {
/* Supported samplerates */
printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, SR_CONF_SAMPLERATE,
- &gvar_dict, sdi) != SR_OK) {
+ if (sr_config_list(sdi->driver, sdi, probe_group, SR_CONF_SAMPLERATE,
+ &gvar_dict) != SR_OK) {
printf("\n");
continue;
}
} else if (srci->key == SR_CONF_BUFFERSIZE) {
/* Supported buffer sizes */
printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, SR_CONF_BUFFERSIZE,
- &gvar_list, sdi) != SR_OK) {
+ if (sr_config_list(sdi->driver, sdi, probe_group,
+ SR_CONF_BUFFERSIZE, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
} else if (srci->key == SR_CONF_TIMEBASE) {
/* Supported time bases */
printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, SR_CONF_TIMEBASE,
- &gvar_list, sdi) != SR_OK) {
+ if (sr_config_list(sdi->driver, sdi, probe_group,
+ SR_CONF_TIMEBASE, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
} else if (srci->key == SR_CONF_VDIV) {
/* Supported volts/div values */
printf(" %s", srci->id);
- if (sr_config_list(sdi->driver, SR_CONF_VDIV,
- &gvar_list, sdi) != SR_OK) {
+ if (sr_config_list(sdi->driver, sdi, probe_group,
+ SR_CONF_VDIV, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
} else if (srci->datatype == SR_T_CHAR) {
printf(" %s: ", srci->id);
- if (sr_config_get(sdi->driver, srci->key,
- &gvar, sdi) == SR_OK) {
+ if (sr_config_get(sdi->driver, sdi, probe_group, srci->key,
+ &gvar) == SR_OK) {
tmp_str = g_strdup(g_variant_get_string(gvar, NULL));
g_variant_unref(gvar);
} else
tmp_str = NULL;
- if (sr_config_list(sdi->driver, srci->key,
- &gvar, sdi) != SR_OK) {
+ if (sr_config_list(sdi->driver, sdi, probe_group, srci->key,
+ &gvar) != SR_OK) {
printf("\n");
continue;
}
} else if (srci->datatype == SR_T_UINT64_RANGE) {
printf(" %s: ", srci->id);
- if (sr_config_list(sdi->driver, srci->key,
- &gvar_list, sdi) != SR_OK) {
+ if (sr_config_list(sdi->driver, sdi, probe_group, srci->key,
+ &gvar_list) != SR_OK) {
printf("\n");
continue;
}
- if (sr_config_get(sdi->driver, srci->key, &gvar, sdi) == SR_OK) {
+ if (sr_config_get(sdi->driver, sdi, NULL, srci->key, &gvar) == SR_OK) {
g_variant_get(gvar, "(tt)", &cur_low, &cur_high);
g_variant_unref(gvar);
} else {
} else if (srci->datatype == SR_T_BOOL) {
printf(" %s: ", srci->id);
- if (sr_config_get(sdi->driver, srci->key,
- &gvar, sdi) == SR_OK) {
+ if (sr_config_get(sdi->driver, sdi, NULL, srci->key,
+ &gvar) == SR_OK) {
if (g_variant_get_boolean(gvar))
printf("on (current), off\n");
else
GSList *l;
GString *out;
int sample_size, ret;
- uint64_t samplerate, output_len, filter_out_len;
+ uint64_t samplerate, output_len, filter_out_len, end_sample;
uint8_t *output_buf, *filter_out;
(void) cb_data;
#ifdef HAVE_SRD
GVariant *gvar;
if (opt_pds && logic_probelist->len) {
- if (sr_config_get(sdi->driver, SR_CONF_SAMPLERATE,
- &gvar, sdi) != SR_OK) {
- g_critical("Unable to initialize protocol "
- "decoders: no samplerate found.");
+ if (sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE,
+ &gvar) == SR_OK) {
+ samplerate = g_variant_get_uint64(gvar);
+ g_variant_unref(gvar);
+ if (srd_session_metadata_set(srd_sess, SRD_CONF_SAMPLERATE,
+ g_variant_new_uint64(samplerate)) != SRD_OK) {
+ g_critical("Failed to configure decode session.");
+ break;
+ }
+ }
+ if (srd_session_start(srd_sess) != SRD_OK) {
+ g_critical("Failed to start decode session.");
break;
}
- samplerate = g_variant_get_uint64(gvar);
- g_variant_unref(gvar);
- srd_session_start(logic_probelist->len, unitsize, samplerate);
}
#endif
break;
case SR_CONF_SAMPLERATE:
samplerate = g_variant_get_uint64(src->data);
g_debug("cli: got samplerate %"PRIu64" Hz", samplerate);
+#ifdef HAVE_SRD
+ if (opt_pds) {
+ if (srd_session_metadata_set(srd_sess, SRD_CONF_SAMPLERATE,
+ g_variant_new_uint64(samplerate)) != SRD_OK) {
+ g_critical("Failed to pass samplerate to decoder.");
+ }
+ }
+#endif
break;
case SR_CONF_SAMPLE_INTERVAL:
samplerate = g_variant_get_uint64(src->data);
if (ret != SR_OK)
break;
- /* What comes out of the filter is guaranteed to be packed into the
+ /*
+ * What comes out of the filter is guaranteed to be packed into the
* minimum size needed to support the number of samples at this sample
- * size. however, the driver may have submitted too much -- cut off
+ * size. however, the driver may have submitted too much. Cut off
* the buffer of the last packet according to the sample limit.
*/
if (limit_samples && (received_samples + logic->length / sample_size >
} else {
if (opt_pds) {
#ifdef HAVE_SRD
- if (srd_session_send(received_samples, (uint8_t*)filter_out,
- filter_out_len) != SRD_OK)
+ end_sample = received_samples + filter_out_len / unitsize;
+ if (srd_session_send(srd_sess, received_samples, end_sample,
+ (uint8_t*)filter_out, filter_out_len) != SRD_OK)
sr_session_stop();
#endif
} else {
if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_STRING)) {
gvar = g_variant_new_string(val_str);
} else if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_INT64)) {
- val_int = strtoll(val_str, &conv, 10);
+ val_int = strtoll(val_str, &conv, 0);
if (!conv || conv == val_str) {
g_critical("Protocol decoder '%s' option '%s' "
"requires a number.", dec->name, o->id);
(GDestroyNotify)g_variant_unref);
all_probes = g_slist_copy(dec->probes);
- all_probes = g_slist_concat(all_probes, dec->opt_probes);
+ all_probes = g_slist_concat(all_probes, g_slist_copy(dec->opt_probes));
for (l = all_probes; l; l = l->next) {
p = l->data;
if (!(val_str = g_hash_table_lookup(hash, p->id)))
(void)dev;
- ret = 0;
pd_ann_visible = g_hash_table_new_full(g_str_hash, g_int_equal,
g_free, NULL);
+ ret = 0;
pd_name = NULL;
pd_opthash = options = probes = NULL;
pdtokens = g_strsplit(pdstring, ",", 0);
break;
}
- if (!(di = srd_inst_new(pd_name, options))) {
+ if (!(di = srd_inst_new(srd_sess, pd_name, options))) {
g_critical("Failed to instantiate protocol decoder %s.", pd_name);
ret = 1;
break;
*/
if (!opt_pd_annotations)
g_hash_table_insert(pd_ann_visible,
- g_strdup(di->inst_id), NULL);
+ g_strdup(di->inst_id), GINT_TO_POINTER(-1));
/* Remap the probes if needed. */
if (srd_inst_probe_set_all(di, probes) != SRD_OK) {
/* First PD goes at the bottom of the stack. */
ids = g_strsplit(pds[0], ":", 0);
- if (!(di_from = srd_inst_find_by_id(ids[0]))) {
+ if (!(di_from = srd_inst_find_by_id(srd_sess, ids[0]))) {
g_strfreev(ids);
g_critical("Cannot stack protocol decoder '%s': "
"instance not found.", pds[0]);
/* Every subsequent PD goes on top. */
for (i = 1; pds[i]; i++) {
ids = g_strsplit(pds[i], ":", 0);
- if (!(di_to = srd_inst_find_by_id(ids[0]))) {
+ if (!(di_to = srd_inst_find_by_id(srd_sess, ids[0]))) {
g_strfreev(ids);
g_critical("Cannot stack protocol decoder '%s': "
"instance not found.", pds[i]);
return 1;
}
g_strfreev(ids);
- if ((ret = srd_inst_stack(di_from, di_to)) != SRD_OK)
+ if ((ret = srd_inst_stack(srd_sess, di_from, di_to)) != SRD_OK)
return 1;
/* Don't show annotation from this PD. Only the last PD in
{
GSList *l;
struct srd_decoder *dec;
- int ann;
+ int ann_class;
char **pds, **pdtok, **keyval, **ann_descr;
/* Set up custom list of PDs and annotations to show. */
- if (opt_pd_annotations) {
- pds = g_strsplit(opt_pd_annotations, ",", 0);
- for (pdtok = pds; *pdtok && **pdtok; pdtok++) {
- ann = 0;
- keyval = g_strsplit(*pdtok, "=", 0);
- if (!(dec = srd_decoder_get_by_id(keyval[0]))) {
- g_critical("Protocol decoder '%s' not found.", keyval[0]);
- return 1;
+ pds = g_strsplit(opt_pd_annotations, ",", 0);
+ for (pdtok = pds; *pdtok && **pdtok; pdtok++) {
+ keyval = g_strsplit(*pdtok, "=", 0);
+ if (!(dec = srd_decoder_get_by_id(keyval[0]))) {
+ g_critical("Protocol decoder '%s' not found.", keyval[0]);
+ return 1;
+ }
+ if (!dec->annotations) {
+ g_critical("Protocol decoder '%s' has no annotations.", keyval[0]);
+ return 1;
+ }
+ ann_class = 0;
+ if (g_strv_length(keyval) == 2) {
+ for (l = dec->annotations; l; l = l->next, ann_class++) {
+ ann_descr = l->data;
+ if (!canon_cmp(ann_descr[0], keyval[1]))
+ /* Found it. */
+ break;
}
- if (!dec->annotations) {
- g_critical("Protocol decoder '%s' has no annotations.", keyval[0]);
+ if (!l) {
+ g_critical("Annotation '%s' not found "
+ "for protocol decoder '%s'.", keyval[1], keyval[0]);
return 1;
}
- if (g_strv_length(keyval) == 2) {
- for (l = dec->annotations; l; l = l->next, ann++) {
- ann_descr = l->data;
- if (!canon_cmp(ann_descr[0], keyval[1]))
- /* Found it. */
- break;
- }
- if (!l) {
- g_critical("Annotation '%s' not found "
- "for protocol decoder '%s'.", keyval[1], keyval[0]);
- return 1;
- }
+ g_debug("cli: Showing protocol decoder %s annotation "
+ "class %d (%s).", keyval[0], ann_class, ann_descr[0]);
+ } else {
+ /* No class specified: show all of them. */
+ ann_class = -1;
+ g_debug("cli: Showing all annotation classes for protocol "
+ "decoder %s.", keyval[0]);
+ }
+ g_hash_table_insert(pd_ann_visible, g_strdup(keyval[0]), GINT_TO_POINTER(ann_class));
+ g_strfreev(keyval);
+ }
+ g_strfreev(pds);
+
+ return 0;
+}
+
+int setup_pd_meta(void)
+{
+ struct srd_decoder *dec;
+ char **pds, **pdtok;
+
+ pd_meta_visible = g_hash_table_new_full(g_str_hash, g_int_equal,
+ g_free, NULL);
+ pds = g_strsplit(opt_pd_meta, ",", 0);
+ for (pdtok = pds; *pdtok && **pdtok; pdtok++) {
+ if (!(dec = srd_decoder_get_by_id(*pdtok))) {
+ g_critical("Protocol decoder '%s' not found.", *pdtok);
+ return 1;
+ }
+ g_debug("cli: Showing protocol decoder meta output from '%s'.", *pdtok);
+ g_hash_table_insert(pd_meta_visible, g_strdup(*pdtok), NULL);
+ }
+ g_strfreev(pds);
+
+ return 0;
+}
+
+int setup_pd_binary(void)
+{
+ GSList *l;
+ struct srd_decoder *dec;
+ int bin_class;
+ char **pds, **pdtok, **keyval, *bin_name;
+
+ pd_binary_visible = g_hash_table_new_full(g_str_hash, g_int_equal,
+ g_free, NULL);
+ pds = g_strsplit(opt_pd_binary, ",", 0);
+ for (pdtok = pds; *pdtok && **pdtok; pdtok++) {
+ keyval = g_strsplit(*pdtok, "=", 0);
+ if (!(dec = srd_decoder_get_by_id(keyval[0]))) {
+ g_critical("Protocol decoder '%s' not found.", keyval[0]);
+ return 1;
+ }
+ if (!dec->binary) {
+ g_critical("Protocol decoder '%s' has no binary output.", keyval[0]);
+ return 1;
+ }
+ bin_class = 0;
+ if (g_strv_length(keyval) == 2) {
+ for (l = dec->binary; l; l = l->next, bin_class++) {
+ bin_name = l->data;
+ if (!canon_cmp(bin_name, keyval[1]))
+ /* Found it. */
+ break;
+ }
+ if (!l) {
+ g_critical("binary output '%s' not found "
+ "for protocol decoder '%s'.", keyval[1], keyval[0]);
+ return 1;
}
- g_debug("cli: showing protocol decoder annotation %d from '%s'", ann, keyval[0]);
- g_hash_table_insert(pd_ann_visible, g_strdup(keyval[0]), GINT_TO_POINTER(ann));
- g_strfreev(keyval);
+ g_debug("cli: Showing protocol decoder %s binary class "
+ "%d (%s).", keyval[0], bin_class, bin_name);
+ } else {
+ /* No class specified: output all of them. */
+ bin_class = -1;
+ g_debug("cli: Showing all binary classes for protocol "
+ "decoder %s.", keyval[0]);
}
- g_strfreev(pds);
+ g_hash_table_insert(pd_binary_visible, g_strdup(keyval[0]), GINT_TO_POINTER(bin_class));
+ g_strfreev(keyval);
}
+ g_strfreev(pds);
return 0;
}
void show_pd_annotations(struct srd_proto_data *pdata, void *cb_data)
{
- int i;
- char **annotations;
+ struct srd_proto_data_annotation *pda;
gpointer ann_format;
+ int format;
/* 'cb_data' is not used in this specific callback. */
(void)cb_data;
/* Not in the list of PDs whose annotations we're showing. */
return;
- if (pdata->ann_format != GPOINTER_TO_INT(ann_format))
+ format = GPOINTER_TO_INT(ann_format);
+ pda = pdata->data;
+ if (format != -1 && pda->ann_format != format)
/* We don't want this particular format from the PD. */
return;
- annotations = pdata->data;
if (opt_loglevel > SR_LOG_WARN)
printf("%"PRIu64"-%"PRIu64" ", pdata->start_sample, pdata->end_sample);
printf("%s: ", pdata->pdo->proto_id);
- for (i = 0; annotations[i]; i++)
- printf("\"%s\" ", annotations[i]);
+ /* Show only the longest annotation. */
+ printf("\"%s\" ", pda->ann_text[0]);
+ printf("\n");
+ fflush(stdout);
+}
+
+void show_pd_meta(struct srd_proto_data *pdata, void *cb_data)
+{
+
+ /* 'cb_data' is not used in this specific callback. */
+ (void)cb_data;
+
+ if (!g_hash_table_lookup_extended(pd_meta_visible,
+ pdata->pdo->di->decoder->id, NULL, NULL))
+ /* Not in the list of PDs whose meta output we're showing. */
+ return;
+
+ if (opt_loglevel > SR_LOG_WARN)
+ printf("%"PRIu64"-%"PRIu64" ", pdata->start_sample, pdata->end_sample);
+ printf("%s: ", pdata->pdo->proto_id);
+ printf("%s: %s", pdata->pdo->meta_name, g_variant_print(pdata->data, FALSE));
printf("\n");
fflush(stdout);
}
+
+void show_pd_binary(struct srd_proto_data *pdata, void *cb_data)
+{
+ struct srd_proto_data_binary *pdb;
+ gpointer classp;
+ int class;
+
+ /* 'cb_data' is not used in this specific callback. */
+ (void)cb_data;
+
+ if (!g_hash_table_lookup_extended(pd_binary_visible,
+ pdata->pdo->di->decoder->id, NULL, (void **)&classp))
+ /* Not in the list of PDs whose meta output we're showing. */
+ return;
+
+ class = GPOINTER_TO_INT(classp);
+ pdb = pdata->data;
+ if (class != -1 && class != pdb->bin_class)
+ /* Not showing this binary class. */
+ return;
+
+ /* Just send the binary output to stdout, no embellishments. */
+ fwrite(pdb->data, pdb->size, 1, stdout);
+ fflush(stdout);
+}
#endif
int setup_output_format(void)
int i;
char *fmtspec;
+ if (opt_output_format && !strcmp(opt_output_format, "sigrok")) {
+ /* Doesn't really exist as an output module - this is
+ * the session save mode. */
+ g_free(opt_output_format);
+ opt_output_format = NULL;
+ }
+
if (!opt_output_format) {
opt_output_format = DEFAULT_OUTPUT_FORMAT;
/* we'll need to remember this so when saving to a file
static int set_dev_options(struct sr_dev_inst *sdi, GHashTable *args)
{
const struct sr_config_info *srci;
+ struct sr_probe_group *pg;
GHashTableIter iter;
gpointer key, value;
int ret;
default:
ret = SR_ERR;
}
- if (val)
- ret = sr_config_set(sdi, srci->key, val);
+ if (val) {
+ pg = select_probe_group(sdi);
+ ret = sr_config_set(sdi, pg, srci->key, val);
+ }
if (ret != SR_OK) {
g_critical("Failed to set device option '%s'.", (char *)key);
return ret;
if (sr_dev_has_option(sdi, SR_CONF_LIMIT_MSEC)) {
gvar = g_variant_new_uint64(time_msec);
- if (sr_config_set(sdi, SR_CONF_LIMIT_MSEC, gvar) != SR_OK) {
+ if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_MSEC, gvar) != SR_OK) {
g_critical("Failed to configure time limit.");
return SR_ERR;
}
} else if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) {
/* Convert to samples based on the samplerate. */
- sr_config_get(sdi->driver, SR_CONF_SAMPLERATE, &gvar, sdi);
+ sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE, &gvar);
samplerate = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
limit_samples = (samplerate) * time_msec / (uint64_t)1000;
return SR_ERR;
}
gvar = g_variant_new_uint64(limit_samples);
- if (sr_config_set(sdi, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) {
+ if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) {
g_critical("Failed to configure time-based sample limit.");
return SR_ERR;
}
return;
}
gvar = g_variant_new_uint64(limit_samples);
- if (sr_config_set(sdi, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) {
+ if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) {
g_critical("Failed to configure sample limit.");
sr_session_destroy();
return;
return;
}
gvar = g_variant_new_uint64(limit_frames);
- if (sr_config_set(sdi, SR_CONF_LIMIT_FRAMES, gvar) != SR_OK) {
+ if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_FRAMES, gvar) != SR_OK) {
g_critical("Failed to configure frame limit.");
sr_session_destroy();
return;
if (opt_continuous)
clear_anykey();
+ sr_session_datafeed_callback_remove_all();
sr_session_destroy();
g_slist_free(devices);
fprintf(stderr, "%s\n", message);
fflush(stderr);
}
+
+ if (log_level & (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL))
+ exit(1);
+
}
int main(int argc, char **argv)
if (opt_pds) {
if (srd_init(NULL) != SRD_OK)
goto done;
- if (register_pds(NULL, opt_pds) != 0)
+ if (srd_session_new(&srd_sess) != SRD_OK) {
+ g_critical("Failed to create new decode session.");
goto done;
- if (srd_pd_output_callback_add(SRD_OUTPUT_ANN,
- show_pd_annotations, NULL) != SRD_OK)
+ }
+ if (register_pds(NULL, opt_pds) != 0)
goto done;
if (setup_pd_stack() != 0)
goto done;
- if (setup_pd_annotations() != 0)
- goto done;
+
+ /* Only one output type is ever shown. */
+ if (opt_pd_binary) {
+ if (setup_pd_binary() != 0)
+ goto done;
+ if (srd_pd_output_callback_add(srd_sess, SRD_OUTPUT_BINARY,
+ show_pd_binary, NULL) != SRD_OK)
+ goto done;
+ } else if (opt_pd_meta) {
+ if (setup_pd_meta() != 0)
+ goto done;
+ if (srd_pd_output_callback_add(srd_sess, SRD_OUTPUT_META,
+ show_pd_meta, NULL) != SRD_OK)
+ goto done;
+ } else {
+ if (opt_pd_annotations)
+ if (setup_pd_annotations() != 0)
+ goto done;
+ if (srd_pd_output_callback_add(srd_sess, SRD_OUTPUT_ANN,
+ show_pd_annotations, NULL) != SRD_OK)
+ goto done;
+ }
}
#endif
projects / sigrok-cli.git / blobdiff