void Device::use(SigSession *owner) throw(QString)
{
DevInst::use(owner);
sr_session_new();
assert(_sdi);
sr_dev_open(_sdi);
if (sr_session_dev_add(_sdi) != SR_OK)
throw QString(tr("Failed to use device."));
}
END_TEST
/*
* Check whether multiple sr_session_new() calls work.
* If any call returns != SR_OK (or segfaults) this test will fail.
*/
START_TEST(test_session_new_multiple)
{
int ret;
struct sr_session *sess1, *sess2, *sess3;
sess1 = sess2 = sess3 = NULL;
/* Multiple sr_session_new() calls must work. */
ret = sr_session_new(srtest_ctx, &sess1);
fail_unless(ret == SR_OK, "sr_session_new() 1 failed: %d.", ret);
ret = sr_session_new(srtest_ctx, &sess2);
fail_unless(ret == SR_OK, "sr_session_new() 2 failed: %d.", ret);
ret = sr_session_new(srtest_ctx, &sess3);
fail_unless(ret == SR_OK, "sr_session_new() 3 failed: %d.", ret);
/* The returned session pointers must all be non-NULL. */
fail_unless(sess1 != NULL);
fail_unless(sess2 != NULL);
fail_unless(sess3 != NULL);
/* The returned session pointers must not be the same. */
fail_unless(sess1 != sess2);
fail_unless(sess1 != sess3);
fail_unless(sess2 != sess3);
/* Destroying any of the sessions must work. */
ret = sr_session_destroy(sess1);
fail_unless(ret == SR_OK, "sr_session_destroy() 1 failed: %d.", ret);
ret = sr_session_destroy(sess2);
fail_unless(ret == SR_OK, "sr_session_destroy() 2 failed: %d.", ret);
ret = sr_session_destroy(sess3);
fail_unless(ret == SR_OK, "sr_session_destroy() 3 failed: %d.", ret);
}
END_TEST
/*
* Check whether sr_session_new() fails for bogus parameters.
* If it returns SR_OK (or segfaults) this test will fail.
*/
START_TEST(test_session_new_bogus)
{
int ret;
ret = sr_session_new(srtest_ctx, NULL);
fail_unless(ret != SR_OK, "sr_session_new(NULL) worked.");
}
END_TEST
/*
* Check whether sr_session_destroy() works.
* If it returns != SR_OK (or segfaults) this test will fail.
*/
START_TEST(test_session_destroy)
{
int ret;
struct sr_session *sess;
sr_session_new(srtest_ctx, &sess);
ret = sr_session_destroy(sess);
fail_unless(ret == SR_OK, "sr_session_destroy() failed: %d.", ret);
}
END_TEST
START_TEST(test_session_trigger_set_get_null)
{
int ret;
struct sr_session *sess;
struct sr_trigger *t;
sr_session_new(srtest_ctx, &sess);
/* Adding a NULL trigger is allowed. */
ret = sr_session_trigger_set(sess, NULL);
fail_unless(ret == SR_OK);
t = sr_session_trigger_get(sess);
fail_unless(t == NULL);
sr_session_destroy(sess);
}
END_TEST
START_TEST(test_session_trigger_set_get)
{
int ret;
struct sr_session *sess;
struct sr_trigger *t1, *t2;
sr_session_new(srtest_ctx, &sess);
t1 = sr_trigger_new("T1");
/* Set a trigger and see if getting it works OK. */
ret = sr_session_trigger_set(sess, t1);
fail_unless(ret == SR_OK);
t2 = sr_session_trigger_get(sess);
fail_unless(t2 != NULL);
fail_unless(t1 == t2);
fail_unless(g_slist_length(t1->stages) == g_slist_length(t2->stages));
fail_unless(!strcmp(t1->name, t2->name));
sr_session_destroy(sess);
}
void run_session(void)
{
GSList *devices;
GHashTable *devargs;
GVariant *gvar;
struct sr_dev_inst *sdi;
uint64_t min_samples, max_samples;
devices = device_scan();
if (!devices) {
g_critical("No devices found.");
return;
}
if (g_slist_length(devices) > 1) {
g_critical("sigrok-cli only supports one device for capturing.");
return;
}
sdi = devices->data;
sr_session_new();
sr_session_datafeed_callback_add(datafeed_in, NULL);
if (sr_dev_open(sdi) != SR_OK) {
g_critical("Failed to open device.");
return;
}
if (sr_session_dev_add(sdi) != SR_OK) {
g_critical("Failed to add device to session.");
sr_session_destroy();
return;
}
if (opt_config) {
if ((devargs = parse_generic_arg(opt_config, FALSE))) {
if (set_dev_options(sdi, devargs) != SR_OK)
return;
g_hash_table_destroy(devargs);
}
}
if (select_channels(sdi) != SR_OK) {
g_critical("Failed to set channels.");
sr_session_destroy();
return;
}
if (opt_triggers) {
if (!parse_triggerstring(sdi, opt_triggers)) {
sr_session_destroy();
return;
}
}
if (opt_continuous) {
if (!sr_dev_has_option(sdi, SR_CONF_CONTINUOUS)) {
g_critical("This device does not support continuous sampling.");
sr_session_destroy();
return;
}
}
if (opt_time) {
if (set_limit_time(sdi) != SR_OK) {
sr_session_destroy();
return;
}
}
if (opt_samples) {
if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK)) {
g_critical("Invalid sample limit '%s'.", opt_samples);
sr_session_destroy();
return;
}
if (sr_config_list(sdi->driver, sdi, NULL,
SR_CONF_LIMIT_SAMPLES, &gvar) == SR_OK) {
/* The device has no compression, or compression is turned
* off, and publishes its sample memory size. */
g_variant_get(gvar, "(tt)", &min_samples, &max_samples);
g_variant_unref(gvar);
if (limit_samples < min_samples) {
g_critical("The device stores at least %"PRIu64
" samples with the current settings.", min_samples);
}
if (limit_samples > max_samples) {
g_critical("The device can store only %"PRIu64
" samples with the current settings.", max_samples);
}
}
gvar = g_variant_new_uint64(limit_samples);
if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) {
g_critical("Failed to configure sample limit.");
sr_session_destroy();
return;
}
}
if (opt_frames) {
if ((sr_parse_sizestring(opt_frames, &limit_frames) != SR_OK)) {
g_critical("Invalid sample limit '%s'.", opt_samples);
sr_session_destroy();
return;
}
gvar = g_variant_new_uint64(limit_frames);
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 (sr_session_start() != SR_OK) {
g_critical("Failed to start session.");
sr_session_destroy();
return;
}
if (opt_continuous)
add_anykey();
sr_session_run();
if (opt_continuous)
clear_anykey();
sr_session_datafeed_callback_remove_all();
sr_session_destroy();
g_slist_free(devices);
}
/**
* Load the session from the specified filename.
*
* @param ctx The context in which to load the session.
* @param filename The name of the session file to load.
* @param session The session to load the file into.
*
* @retval SR_OK Success
* @retval SR_ERR_MALLOC Memory allocation error
* @retval SR_ERR_DATA Malformed session file
* @retval SR_ERR This is not a session file
*/
SR_API int sr_session_load(struct sr_context *ctx, const char *filename,
struct sr_session **session)
{
GKeyFile *kf;
GError *error;
struct zip *archive;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *ch;
int ret, i, j;
uint64_t tmp_u64;
int total_channels, total_analog, k;
GSList *l;
int unitsize;
char **sections, **keys, *val;
char channelname[SR_MAX_CHANNELNAME_LEN + 1];
gboolean file_has_logic;
if ((ret = sr_sessionfile_check(filename)) != SR_OK)
return ret;
if (!(archive = zip_open(filename, 0, NULL)))
return SR_ERR;
if (zip_stat(archive, "metadata", 0, &zs) < 0) {
zip_discard(archive);
return SR_ERR;
}
kf = sr_sessionfile_read_metadata(archive, &zs);
zip_discard(archive);
if (!kf)
return SR_ERR_DATA;
if ((ret = sr_session_new(ctx, session)) != SR_OK) {
g_key_file_free(kf);
return ret;
}
total_channels = 0;
error = NULL;
ret = SR_OK;
file_has_logic = FALSE;
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i] && ret == SR_OK; i++) {
if (!strcmp(sections[i], "global"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
sdi = NULL;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
/* File contains analog data if there are analog channels. */
total_analog = g_key_file_get_integer(kf, sections[i],
"total analog", &error);
if (total_analog > 0 && !error)
sdi = sr_session_prepare_sdi(filename, session);
g_clear_error(&error);
/* File contains logic data if a capturefile is set. */
val = g_key_file_get_string(kf, sections[i],
"capturefile", &error);
if (val && !error) {
if (!sdi)
sdi = sr_session_prepare_sdi(filename, session);
sr_config_set(sdi, NULL, SR_CONF_CAPTUREFILE,
g_variant_new_string(val));
g_free(val);
file_has_logic = TRUE;
}
g_clear_error(&error);
for (j = 0; keys[j]; j++) {
if (!strcmp(keys[j], "samplerate")) {
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!sdi || !val || sr_parse_sizestring(val,
&tmp_u64) != SR_OK) {
g_free(val);
ret = SR_ERR_DATA;
break;
}
g_free(val);
sr_config_set(sdi, NULL, SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64));
} else if (!strcmp(keys[j], "unitsize") && file_has_logic) {
unitsize = g_key_file_get_integer(kf, sections[i],
keys[j], &error);
if (!sdi || unitsize <= 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(unitsize));
} else if (!strcmp(keys[j], "total probes")) {
total_channels = g_key_file_get_integer(kf,
sections[i], keys[j], &error);
if (!sdi || total_channels < 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_NUM_LOGIC_CHANNELS,
g_variant_new_int32(total_channels));
for (k = 0; k < total_channels; k++) {
g_snprintf(channelname, sizeof(channelname),
"%d", k);
sr_channel_new(sdi, k, SR_CHANNEL_LOGIC,
FALSE, channelname);
}
} else if (!strcmp(keys[j], "total analog")) {
total_analog = g_key_file_get_integer(kf,
sections[i], keys[j], &error);
if (!sdi || total_analog < 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_NUM_ANALOG_CHANNELS,
g_variant_new_int32(total_analog));
for (k = total_channels; k < (total_channels + total_analog); k++) {
g_snprintf(channelname, sizeof(channelname),
"%d", k);
sr_channel_new(sdi, k, SR_CHANNEL_ANALOG,
FALSE, channelname);
}
} else if (!strncmp(keys[j], "probe", 5)) {
tmp_u64 = g_ascii_strtoull(keys[j] + 5, NULL, 10);
if (!sdi || tmp_u64 == 0 || tmp_u64 > G_MAXINT) {
ret = SR_ERR_DATA;
break;
}
ch = g_slist_nth_data(sdi->channels, tmp_u64 - 1);
if (!ch) {
ret = SR_ERR_DATA;
break;
}
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!val) {
ret = SR_ERR_DATA;
break;
}
/* sr_session_save() */
sr_dev_channel_name_set(ch, val);
g_free(val);
sr_dev_channel_enable(ch, TRUE);
} else if (!strncmp(keys[j], "analog", 6)) {
tmp_u64 = g_ascii_strtoull(keys[j]+6, NULL, 10);
if (!sdi || tmp_u64 == 0 || tmp_u64 > G_MAXINT) {
ret = SR_ERR_DATA;
break;
}
ch = NULL;
for (l = sdi->channels; l; l = l->next) {
ch = l->data;
if ((guint64)ch->index == tmp_u64 - 1)
break;
else
ch = NULL;
}
if (!ch) {
ret = SR_ERR_DATA;
break;
}
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!val) {
ret = SR_ERR_DATA;
break;
}
/* sr_session_save() */
sr_dev_channel_name_set(ch, val);
g_free(val);
sr_dev_channel_enable(ch, TRUE);
}
}
g_strfreev(keys);
}
}
g_strfreev(sections);
g_key_file_free(kf);
if (error) {
sr_err("Failed to parse metadata: %s", error->message);
g_error_free(error);
}
return ret;
}
void MainWindow::on_action_Get_samples_triggered()
{
uint64_t samplerate;
QString s;
GSList *devs = NULL;
int opt_dev;
struct sr_dev *dev;
QComboBox *n = ui->comboBoxNumSamples;
opt_dev = 0; /* FIXME */
/*
* The number of samples to get is a drop-down list, but you can also
* manually enter a value. If the latter, we have to get the value from
* the lineEdit object, otherwise via itemData() and the list index.
*/
if (n->lineEdit() != NULL) {
limit_samples = n->lineEdit()->text().toLongLong();
} else {
limit_samples = n->itemData(n->currentIndex()).toLongLong();
}
samplerate = ui->comboBoxSampleRate->itemData(
ui->comboBoxSampleRate->currentIndex()).toLongLong();
/* TODO: Sanity checks. */
/* TODO: Assumes unitsize == 1. */
if (!(sample_buffer = (uint8_t *)malloc(limit_samples))) {
/* TODO: Error handling. */
return;
}
sr_session_new();
sr_session_datafeed_callback_add(datafeed_in);
devs = sr_dev_list();
dev = (struct sr_dev *)g_slist_nth_data(devs, opt_dev);
/* Set the number of samples we want to get from the device. */
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK) {
qDebug("Failed to set sample limit.");
sr_session_destroy();
return;
}
if (sr_session_dev_add(dev) != SR_OK) {
qDebug("Failed to use device.");
sr_session_destroy();
return;
}
/* Set the samplerate. */
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_SAMPLERATE, &samplerate) != SR_OK) {
qDebug("Failed to set samplerate.");
sr_session_destroy();
return;
};
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_PROBECONFIG, (char *)dev->probes) != SR_OK) {
qDebug("Failed to configure probes.");
sr_session_destroy();
return;
}
if (sr_session_start() != SR_OK) {
qDebug("Failed to start session.");
sr_session_destroy();
return;
}
progress = new QProgressDialog("Getting samples from logic analyzer...",
"Abort", 0, limit_samples, this);
progress->setWindowModality(Qt::WindowModal);
progress->setMinimumDuration(100);
sr_session_run();
sr_session_stop();
sr_session_destroy();
for (int i = 0; i < getNumChannels(); ++i) {
channelForms[i]->setNumSamples(limit_samples);
// channelForms[i]->setSampleStart(0);
// channelForms[i]->setSampleEnd(limit_samples);
/* If any of the scale factors change, update all of them.. */
connect(channelForms[i], SIGNAL(scaleFactorChanged(float)),
w, SLOT(updateScaleFactors(float)));
channelForms[i]->generatePainterPath();
// channelForms[i]->update();
}
setNumSamples(limit_samples);
/* Enable the relevant labels/buttons. */
ui->labelSampleStart->setEnabled(true);
ui->labelSampleEnd->setEnabled(true);
ui->labelScaleFactor->setEnabled(true);
ui->action_Save_as->setEnabled(true);
// sr_hw_get_samples_shutdown(&ctx, 1000);
}
/**
* Load the session from the specified filename.
*
* @param filename The name of the session file to load. Must not be NULL.
*
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments,
* SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon
* other errors.
*/
SR_API int sr_session_load(const char *filename)
{
GKeyFile *kf;
GPtrArray *capturefiles;
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *probe;
int ret, devcnt, i, j, k;
uint16_t probenum;
uint64_t tmp_u64, total_probes, enabled_probes;
uint16_t p;
char **sections, **keys, *metafile, *val, s[11];
char probename[SR_MAX_PROBENAME_LEN + 1];
int mode = LOGIC;
int channel_type = SR_CHANNEL_LOGIC;
double tmp_double;
if (!filename) {
sr_err("%s: filename was NULL", __func__);
return SR_ERR_ARG;
}
if (!(archive = zip_open(filename, 0, &ret))) {
sr_dbg("Failed to open session file: zip error %d", ret);
return SR_ERR;
}
/* read "metadata" */
if (zip_stat(archive, "header", 0, &zs) == -1) {
sr_dbg("Not a valid DSView data file.");
return SR_ERR;
}
if (!(metafile = g_try_malloc(zs.size))) {
sr_err("%s: metafile malloc failed", __func__);
return SR_ERR_MALLOC;
}
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
sr_dbg("Failed to parse metadata.");
return SR_ERR;
}
sr_session_new();
devcnt = 0;
capturefiles = g_ptr_array_new_with_free_func(g_free);
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i]; i++) {
if (!strcmp(sections[i], "version"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "header", 6)) {
/* device section */
sdi = NULL;
enabled_probes = total_probes = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "device mode")) {
mode = strtoull(val, NULL, 10);
} else if (!strcmp(keys[j], "capturefile")) {
sdi = sr_dev_inst_new(mode, devcnt, SR_ST_ACTIVE, NULL, NULL, NULL);
sdi->driver = &session_driver;
if (devcnt == 0)
/* first device, init the driver */
sdi->driver->init(NULL);
sr_dev_open(sdi);
sr_session_dev_add(sdi);
sdi->driver->config_set(SR_CONF_SESSIONFILE,
g_variant_new_bytestring(filename), sdi, NULL, NULL);
sdi->driver->config_set(SR_CONF_CAPTUREFILE,
g_variant_new_bytestring(val), sdi, NULL, NULL);
g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) {
sr_parse_sizestring(val, &tmp_u64);
sdi->driver->config_set(SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "unitsize")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "total samples")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_LIMIT_SAMPLES,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "hDiv")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_TIMEBASE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "total probes")) {
total_probes = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES,
g_variant_new_uint64(total_probes), sdi, NULL, NULL);
channel_type = (mode == DSO) ? SR_CHANNEL_DSO :
(mode == ANALOG) ? SR_CHANNEL_ANALOG : SR_CHANNEL_LOGIC;
for (p = 0; p < total_probes; p++) {
snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
if (!(probe = sr_channel_new(p, channel_type, FALSE,
probename)))
return SR_ERR;
sdi->channels = g_slist_append(sdi->channels, probe);
}
} else if (!strncmp(keys[j], "probe", 5)) {
if (!sdi)
continue;
enabled_probes++;
tmp_u64 = strtoul(keys[j]+5, NULL, 10);
/* sr_session_save() */
sr_dev_probe_name_set(sdi, tmp_u64, val);
sr_dev_probe_enable(sdi, tmp_u64, TRUE);
} else if (!strncmp(keys[j], "trigger", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
sr_dev_trigger_set(sdi, probenum, val);
} else if (!strncmp(keys[j], "enable", 6)) {
probenum = strtoul(keys[j]+6, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_EN_CH,
g_variant_new_boolean(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "coupling", 8)) {
probenum = strtoul(keys[j]+8, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_COUPLING,
g_variant_new_byte(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vDiv", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_VDIV,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vFactor", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_FACTOR,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vPos", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_double = strtod(val, NULL);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_VPOS,
g_variant_new_double(tmp_double), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "period", 6)) {
probenum = strtoul(keys[j]+6, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_PERIOD,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "pcnt", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_PCNT,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "max", 3)) {
probenum = strtoul(keys[j]+3, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_MAX,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "min", 3)) {
probenum = strtoul(keys[j]+3, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_MIN,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
}
}
g_strfreev(keys);
}
devcnt++;
}
g_strfreev(sections);
g_key_file_free(kf);
return SR_OK;
}
/**
* Load the session from the specified filename.
*
* @param ctx The context in which to load the session.
* @param filename The name of the session file to load.
* @param session The session to load the file into.
*
* @retval SR_OK Success
* @retval SR_ERR_MALLOC Memory allocation error
* @retval SR_ERR_DATA Malformed session file
* @retval SR_ERR This is not a session file
*/
SR_API int sr_session_load(struct sr_context *ctx, const char *filename,
struct sr_session **session)
{
GKeyFile *kf;
GPtrArray *capturefiles;
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *ch;
int ret, i, j;
uint64_t tmp_u64, total_channels, p;
char **sections, **keys, *metafile, *val;
char channelname[SR_MAX_CHANNELNAME_LEN + 1];
if ((ret = sr_sessionfile_check(filename)) != SR_OK)
return ret;
if (!(archive = zip_open(filename, 0, &ret)))
return SR_ERR;
if (zip_stat(archive, "metadata", 0, &zs) == -1)
return SR_ERR;
if (!(metafile = g_try_malloc(zs.size))) {
sr_err("%s: metafile malloc failed", __func__);
return SR_ERR_MALLOC;
}
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
sr_dbg("Failed to parse metadata.");
return SR_ERR;
}
if ((ret = sr_session_new(ctx, session)) != SR_OK)
return ret;
ret = SR_OK;
capturefiles = g_ptr_array_new_with_free_func(g_free);
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i] && ret == SR_OK; i++) {
if (!strcmp(sections[i], "global"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
sdi = NULL;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "capturefile")) {
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->driver = &session_driver;
sdi->status = SR_ST_ACTIVE;
if (!session_driver_initialized) {
/* first device, init the driver */
session_driver_initialized = 1;
sdi->driver->init(sdi->driver, NULL);
}
sr_dev_open(sdi);
sr_session_dev_add(*session, sdi);
(*session)->owned_devs = g_slist_append(
(*session)->owned_devs, sdi);
sdi->driver->config_set(SR_CONF_SESSIONFILE,
g_variant_new_string(filename), sdi, NULL);
sdi->driver->config_set(SR_CONF_CAPTUREFILE,
g_variant_new_string(val), sdi, NULL);
g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) {
if (!sdi) {
ret = SR_ERR_DATA;
break;
}
sr_parse_sizestring(val, &tmp_u64);
sdi->driver->config_set(SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64), sdi, NULL);
} else if (!strcmp(keys[j], "unitsize")) {
if (!sdi) {
ret = SR_ERR_DATA;
break;
}
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(tmp_u64), sdi, NULL);
} else if (!strcmp(keys[j], "total probes")) {
if (!sdi) {
ret = SR_ERR_DATA;
break;
}
total_channels = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_NUM_LOGIC_CHANNELS,
g_variant_new_uint64(total_channels), sdi, NULL);
for (p = 0; p < total_channels; p++) {
snprintf(channelname, SR_MAX_CHANNELNAME_LEN, "%" PRIu64, p);
sr_channel_new(sdi, p, SR_CHANNEL_LOGIC, FALSE,
channelname);
}
} else if (!strncmp(keys[j], "probe", 5)) {
if (!sdi) {
ret = SR_ERR_DATA;
break;
}
tmp_u64 = strtoul(keys[j]+5, NULL, 10) - 1;
ch = g_slist_nth_data(sdi->channels, tmp_u64);
/* sr_session_save() */
sr_dev_channel_name_set(ch, val);
sr_dev_channel_enable(ch, TRUE);
}
}
g_strfreev(keys);
}
}
g_strfreev(sections);
g_key_file_free(kf);
return ret;
}
int sr_session_load(const char *filename)
{
GKeyFile *kf;
GPtrArray *capturefiles;
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
struct sr_session *session;
struct sr_device *device;
struct sr_probe *probe;
int ret, err, probenum, devcnt, i, j;
uint64_t tmp_u64, total_probes, enabled_probes, p;
char **sections, **keys, *metafile, *val, c;
if (!(archive = zip_open(filename, 0, &err))) {
sr_dbg("Failed to open session file: zip error %d", err);
return SR_ERR;
}
/* check "version" */
if (!(zf = zip_fopen(archive, "version", 0))) {
sr_dbg("Not a sigrok session file.");
return SR_ERR;
}
ret = zip_fread(zf, &c, 1);
if (ret != 1 || c != '1') {
sr_dbg("Not a valid sigrok session file.");
return SR_ERR;
}
zip_fclose(zf);
/* read "metadata" */
if (zip_stat(archive, "metadata", 0, &zs) == -1) {
sr_dbg("Not a valid sigrok session file.");
return SR_ERR;
}
if (!(metafile = g_try_malloc(zs.size))) {
sr_err("session file: %s: metafile malloc failed", __func__);
return SR_ERR_MALLOC;
}
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
sr_dbg("Failed to parse metadata.");
return SR_ERR;
}
session = sr_session_new();
devcnt = 0;
capturefiles = g_ptr_array_new_with_free_func(g_free);
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i]; i++) {
if (!strcmp(sections[i], "global"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
device = NULL;
enabled_probes = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "capturefile")) {
device = sr_device_new(&session_driver, devcnt, 0);
if (devcnt == 0)
/* first device, init the plugin */
device->plugin->init((char *)filename);
sr_session_device_add(device);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTUREFILE, val);
g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) {
tmp_u64 = sr_parse_sizestring(val);
device->plugin->set_configuration(devcnt, SR_HWCAP_SAMPLERATE, &tmp_u64);
} else if (!strcmp(keys[j], "unitsize")) {
tmp_u64 = strtoull(val, NULL, 10);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTURE_UNITSIZE, &tmp_u64);
} else if (!strcmp(keys[j], "total probes")) {
total_probes = strtoull(val, NULL, 10);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTURE_NUM_PROBES, &total_probes);
for (p = 1; p <= total_probes; p++)
sr_device_probe_add(device, NULL);
} else if (!strncmp(keys[j], "probe", 5)) {
if (!device)
continue;
enabled_probes++;
tmp_u64 = strtoul(keys[j]+5, NULL, 10);
sr_device_probe_name(device, tmp_u64, val);
} else if (!strncmp(keys[j], "trigger", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
sr_device_trigger_set(device, probenum, val);
}
}
g_strfreev(keys);
for (p = enabled_probes; p < total_probes; p++) {
probe = g_slist_nth_data(device->probes, p);
probe->enabled = FALSE;
}
}
}
g_strfreev(sections);
g_key_file_free(kf);
return SR_OK;
}
/**
* Load the session from the specified filename.
*
* @param ctx The context in which to load the session.
* @param filename The name of the session file to load.
* @param session The session to load the file into.
*
* @retval SR_OK Success
* @retval SR_ERR_MALLOC Memory allocation error
* @retval SR_ERR_DATA Malformed session file
* @retval SR_ERR This is not a session file
*/
SR_API int sr_session_load(struct sr_context *ctx, const char *filename,
struct sr_session **session)
{
GKeyFile *kf;
GError *error;
struct zip *archive;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *ch;
int ret, i, j;
uint64_t tmp_u64;
int total_channels, k;
int unitsize;
char **sections, **keys, *val;
char channelname[SR_MAX_CHANNELNAME_LEN + 1];
if ((ret = sr_sessionfile_check(filename)) != SR_OK)
return ret;
if (!(archive = zip_open(filename, 0, NULL)))
return SR_ERR;
if (zip_stat(archive, "metadata", 0, &zs) < 0) {
zip_discard(archive);
return SR_ERR;
}
kf = sr_sessionfile_read_metadata(archive, &zs);
zip_discard(archive);
if (!kf)
return SR_ERR_DATA;
if ((ret = sr_session_new(ctx, session)) != SR_OK) {
g_key_file_free(kf);
return ret;
}
error = NULL;
ret = SR_OK;
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i] && ret == SR_OK; i++) {
if (!strcmp(sections[i], "global"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
sdi = NULL;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
if (!strcmp(keys[j], "capturefile")) {
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!val) {
ret = SR_ERR_DATA;
break;
}
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->driver = &session_driver;
sdi->status = SR_ST_ACTIVE;
if (!session_driver_initialized) {
/* first device, init the driver */
session_driver_initialized = 1;
sdi->driver->init(sdi->driver, NULL);
}
sr_dev_open(sdi);
sr_session_dev_add(*session, sdi);
(*session)->owned_devs = g_slist_append(
(*session)->owned_devs, sdi);
sr_config_set(sdi, NULL, SR_CONF_SESSIONFILE,
g_variant_new_string(filename));
sr_config_set(sdi, NULL, SR_CONF_CAPTUREFILE,
g_variant_new_string(val));
g_free(val);
} else if (!strcmp(keys[j], "samplerate")) {
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!sdi || !val || sr_parse_sizestring(val,
&tmp_u64) != SR_OK) {
g_free(val);
ret = SR_ERR_DATA;
break;
}
g_free(val);
sr_config_set(sdi, NULL, SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64));
} else if (!strcmp(keys[j], "unitsize")) {
unitsize = g_key_file_get_integer(kf, sections[i],
keys[j], &error);
if (!sdi || unitsize <= 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(unitsize));
} else if (!strcmp(keys[j], "total probes")) {
total_channels = g_key_file_get_integer(kf,
sections[i], keys[j], &error);
if (!sdi || total_channels < 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_NUM_LOGIC_CHANNELS,
g_variant_new_int32(total_channels));
for (k = 0; k < total_channels; k++) {
g_snprintf(channelname, sizeof channelname,
"%d", k);
sr_channel_new(sdi, k, SR_CHANNEL_LOGIC,
FALSE, channelname);
}
} else if (!strncmp(keys[j], "probe", 5)) {
tmp_u64 = g_ascii_strtoull(keys[j]+5, NULL, 10);
if (!sdi || tmp_u64 == 0 || tmp_u64 > G_MAXINT) {
ret = SR_ERR_DATA;
break;
}
ch = g_slist_nth_data(sdi->channels, tmp_u64 - 1);
if (!ch) {
ret = SR_ERR_DATA;
break;
}
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!val) {
ret = SR_ERR_DATA;
break;
}
/* sr_session_save() */
sr_dev_channel_name_set(ch, val);
g_free(val);
sr_dev_channel_enable(ch, TRUE);
}
}
g_strfreev(keys);
}
}
g_strfreev(sections);
g_key_file_free(kf);
if (error) {
sr_err("Failed to parse metadata: %s", error->message);
g_error_free(error);
}
return ret;
}
static void run_session(void)
{
struct sr_dev *dev;
GHashTable *devargs;
int num_devs, max_probes, i;
uint64_t time_msec;
char **probelist, *devspec;
devargs = NULL;
if (opt_dev) {
devargs = parse_generic_arg(opt_dev);
devspec = g_hash_table_lookup(devargs, "sigrok_key");
dev = parse_devstring(devspec);
if (!dev) {
g_critical("Device not found.");
return;
}
g_hash_table_remove(devargs, "sigrok_key");
} else {
num_devs = num_real_devs();
if (num_devs == 1) {
/* No device specified, but there is only one. */
devargs = NULL;
dev = parse_devstring("0");
} else if (num_devs == 0) {
g_critical("No devices found.");
return;
} else {
g_critical("%d devices found, please select one.", num_devs);
return;
}
}
sr_session_new();
sr_session_datafeed_callback_add(datafeed_in);
if (sr_session_dev_add(dev) != SR_OK) {
g_critical("Failed to use device.");
sr_session_destroy();
return;
}
if (devargs) {
if (set_dev_options(dev, devargs) != SR_OK) {
sr_session_destroy();
return;
}
g_hash_table_destroy(devargs);
}
if (select_probes(dev) != SR_OK)
return;
if (opt_continuous) {
if (!sr_driver_hwcap_exists(dev->driver, SR_HWCAP_CONTINUOUS)) {
g_critical("This device does not support continuous sampling.");
sr_session_destroy();
return;
}
}
if (opt_triggers) {
probelist = sr_parse_triggerstring(dev, opt_triggers);
if (!probelist) {
sr_session_destroy();
return;
}
max_probes = g_slist_length(dev->probes);
for (i = 0; i < max_probes; i++) {
if (probelist[i]) {
sr_dev_trigger_set(dev, i + 1, probelist[i]);
g_free(probelist[i]);
}
}
g_free(probelist);
}
if (opt_time) {
time_msec = sr_parse_timestring(opt_time);
if (time_msec == 0) {
g_critical("Invalid time '%s'", opt_time);
sr_session_destroy();
return;
}
if (sr_driver_hwcap_exists(dev->driver, SR_HWCAP_LIMIT_MSEC)) {
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_MSEC, &time_msec) != SR_OK) {
g_critical("Failed to configure time limit.");
sr_session_destroy();
return;
}
}
else {
/* time limit set, but device doesn't support this...
* convert to samples based on the samplerate.
*/
limit_samples = 0;
if (sr_dev_has_hwcap(dev, SR_HWCAP_SAMPLERATE)) {
const uint64_t *samplerate;
sr_dev_info_get(dev, SR_DI_CUR_SAMPLERATE,
(const void **)&samplerate);
limit_samples = (*samplerate) * time_msec / (uint64_t)1000;
}
if (limit_samples == 0) {
g_critical("Not enough time at this samplerate.");
sr_session_destroy();
return;
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK) {
g_critical("Failed to configure time-based sample limit.");
sr_session_destroy();
return;
}
}
}
if (opt_samples) {
if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK)
|| (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK)) {
g_critical("Failed to configure sample limit.");
sr_session_destroy();
return;
}
}
if (opt_frames) {
if ((sr_parse_sizestring(opt_frames, &limit_frames) != SR_OK)
|| (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_FRAMES, &limit_frames) != SR_OK)) {
printf("Failed to configure frame limit.\n");
sr_session_destroy();
return;
}
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_PROBECONFIG, (char *)dev->probes) != SR_OK) {
g_critical("Failed to configure probes.");
sr_session_destroy();
return;
}
if (sr_session_start() != SR_OK) {
g_critical("Failed to start session.");
sr_session_destroy();
return;
}
if (opt_continuous)
add_anykey();
sr_session_run();
if (opt_continuous)
clear_anykey();
if (opt_output_file && default_output_format) {
if (sr_session_save(opt_output_file) != SR_OK)
g_critical("Failed to save session.");
}
sr_session_destroy();
}
static void load_input_file_format(void)
{
GHashTable *fmtargs = NULL;
struct stat st;
struct sr_input *in;
struct sr_input_format *input_format;
char *fmtspec = NULL;
if (opt_input_format) {
fmtargs = parse_generic_arg(opt_input_format);
fmtspec = g_hash_table_lookup(fmtargs, "sigrok_key");
}
if (!(input_format = determine_input_file_format(opt_input_file,
fmtspec))) {
/* The exact cause was already logged. */
return;
}
;
if (fmtargs)
g_hash_table_remove(fmtargs, "sigrok_key");
if (stat(opt_input_file, &st) == -1) {
g_critical("Failed to load %s: %s", opt_input_file,
strerror(errno));
exit(1);
}
/* Initialize the input module. */
if (!(in = g_try_malloc(sizeof(struct sr_input)))) {
g_critical("Failed to allocate input module.");
exit(1);
}
in->format = input_format;
in->param = fmtargs;
if (in->format->init) {
if (in->format->init(in) != SR_OK) {
g_critical("Input format init failed.");
exit(1);
}
}
if (select_probes(in->vdev) > 0)
return;
sr_session_new();
sr_session_datafeed_callback_add(datafeed_in);
if (sr_session_dev_add(in->vdev) != SR_OK) {
g_critical("Failed to use device.");
sr_session_destroy();
return;
}
input_format->loadfile(in, opt_input_file);
if (opt_output_file && default_output_format) {
if (sr_session_save(opt_output_file) != SR_OK)
g_critical("Failed to save session.");
}
sr_session_destroy();
if (fmtargs)
g_hash_table_destroy(fmtargs);
}
