X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=session_file.c;h=e4f41a5e9c7c18b747c43a4dc5f0874434fb9c39;hb=5097b0d0912165429aceddb5febbf68467b623f5;hp=c8939e5f300b6a4c4f885314f7afa1f8f87d56e4;hpb=f5a443f27ad0e99f8f0f93867a1f298d7a6a327a;p=libsigrok.git diff --git a/session_file.c b/session_file.c index c8939e5f..e4f41a5e 100644 --- a/session_file.c +++ b/session_file.c @@ -1,7 +1,7 @@ /* * This file is part of the sigrok project. * - * Copyright (C) 2011 Bert Vermeulen + * Copyright (C) 2010-2012 Bert Vermeulen * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,20 +17,29 @@ * along with this program. If not, see . */ -#include "config.h" #include #include #include #include #include #include -#include -#include +#include "config.h" +#include "sigrok.h" +#include "sigrok-internal.h" extern struct sr_session *session; -extern struct sr_device_plugin session_driver; +extern SR_PRIV struct sr_dev_plugin session_driver; -int sr_session_load(const char *filename) +/** + * 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; @@ -38,42 +47,54 @@ int sr_session_load(const char *filename) struct zip_file *zf; struct zip_stat zs; struct sr_session *session; - struct sr_device *device; + struct sr_dev *dev; 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; + char probename[SR_MAX_PROBENAME_LEN + 1]; + + if (!filename) { + sr_err("session file: %s: filename was NULL", __func__); + return SR_ERR_ARG; + } if (!(archive = zip_open(filename, 0, &err))) { - g_debug("Failed to open session file: zip error %d", err); + sr_dbg("session file: Failed to open session file: zip " + "error %d", err); return SR_ERR; } /* check "version" */ if (!(zf = zip_fopen(archive, "version", 0))) { - g_debug("Not a sigrok session file."); + sr_dbg("session file: Not a sigrok session file."); return SR_ERR; } ret = zip_fread(zf, &c, 1); if (ret != 1 || c != '1') { - g_debug("Not a valid sigrok session file."); + sr_dbg("session file: Not a valid sigrok session file."); return SR_ERR; } zip_fclose(zf); /* read "metadata" */ if (zip_stat(archive, "metadata", 0, &zs) == -1) { - g_debug("Not a valid sigrok session file."); + sr_dbg("session file: Not a valid sigrok session file."); return SR_ERR; } - metafile = g_malloc(zs.size); + + 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)) { - g_debug("Failed to parse metadata."); + sr_dbg("session file: Failed to parse metadata."); return SR_ERR; } @@ -88,44 +109,46 @@ int sr_session_load(const char *filename) continue; if (!strncmp(sections[i], "device ", 7)) { /* device section */ - device = NULL; + dev = 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); + dev = sr_dev_new(&session_driver, devcnt); 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); + dev->plugin->init((char *)filename); + sr_session_dev_add(dev); + dev->plugin->config_set(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); + sr_parse_sizestring(val, &tmp_u64); + dev->plugin->config_set(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); + dev->plugin->config_set(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); + dev->plugin->config_set(devcnt, SR_HWCAP_CAPTURE_NUM_PROBES, &total_probes); + for (p = 0; p < total_probes; p++) { + snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p); + sr_dev_probe_add(dev, probename); + } } else if (!strncmp(keys[j], "probe", 5)) { - if (!device) + if (!dev) continue; enabled_probes++; tmp_u64 = strtoul(keys[j]+5, NULL, 10); - sr_device_probe_name(device, tmp_u64, val); + sr_dev_probe_name(dev, tmp_u64, val); } else if (!strncmp(keys[j], "trigger", 7)) { probenum = strtoul(keys[j]+7, NULL, 10); - sr_device_trigger_set(device, probenum, val); + sr_dev_trigger_set(dev, probenum, val); } } g_strfreev(keys); for (p = enabled_probes; p < total_probes; p++) { - probe = g_slist_nth_data(device->probes, p); + probe = g_slist_nth_data(dev->probes, p); probe->enabled = FALSE; } } @@ -136,11 +159,20 @@ int sr_session_load(const char *filename) return SR_OK; } +/** + * Save the current session to the specified file. + * + * @param filename The name of the file where to save the current session. + * Must not be NULL. + * + * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR + * upon other errors. + */ int sr_session_save(const char *filename) { GSList *l, *p, *d; FILE *meta; - struct sr_device *device; + struct sr_dev *dev; struct sr_probe *probe; struct sr_datastore *ds; struct zip *zipfile; @@ -149,6 +181,11 @@ int sr_session_save(const char *filename) uint64_t samplerate; char version[1], rawname[16], metafile[32], *buf, *s; + if (!filename) { + sr_err("session file: %s: filename was NULL", __func__); + return SR_ERR_ARG; + } + /* Quietly delete it first, libzip wants replace ops otherwise. */ unlink(filename); if (!(zipfile = zip_open(filename, ZIP_CREATE, &error))) @@ -159,8 +196,8 @@ int sr_session_save(const char *filename) if (!(versrc = zip_source_buffer(zipfile, version, 1, 0))) return SR_ERR; if (zip_add(zipfile, "version", versrc) == -1) { - g_message("error saving version into zipfile: %s", - zip_strerror(zipfile)); + sr_info("session file: error saving version into zipfile: %s", + zip_strerror(zipfile)); return SR_ERR; } @@ -176,28 +213,28 @@ int sr_session_save(const char *filename) /* all datastores in all devices */ devcnt = 1; - for (l = session->devices; l; l = l->next) { - device = l->data; + for (l = session->devs; l; l = l->next) { + dev = l->data; /* metadata */ fprintf(meta, "[device %d]\n", devcnt); - if (device->plugin) - fprintf(meta, "driver = %s\n", device->plugin->name); + if (dev->plugin) + fprintf(meta, "driver = %s\n", dev->plugin->name); - ds = device->datastore; + ds = dev->datastore; if (ds) { /* metadata */ fprintf(meta, "capturefile = logic-%d\n", devcnt); fprintf(meta, "unitsize = %d\n", ds->ds_unitsize); - fprintf(meta, "total probes = %d\n", g_slist_length(device->probes)); - if (sr_device_has_hwcap(device, SR_HWCAP_SAMPLERATE)) { - samplerate = *((uint64_t *) device->plugin->get_device_info( - device->plugin_index, SR_DI_CUR_SAMPLERATE)); + fprintf(meta, "total probes = %d\n", g_slist_length(dev->probes)); + if (sr_dev_has_hwcap(dev, SR_HWCAP_SAMPLERATE)) { + samplerate = *((uint64_t *) dev->plugin->dev_info_get( + dev->plugin_index, SR_DI_CUR_SAMPLERATE)); s = sr_samplerate_string(samplerate); fprintf(meta, "samplerate = %s\n", s); - free(s); + g_free(s); } probecnt = 1; - for (p = device->probes; p; p = p->next) { + for (p = dev->probes; p; p = p->next) { probe = p->data; if (probe->enabled) { if (probe->name) @@ -209,8 +246,14 @@ int sr_session_save(const char *filename) } /* dump datastore into logic-n */ - buf = malloc(ds->num_units * ds->ds_unitsize + + buf = g_try_malloc(ds->num_units * ds->ds_unitsize + DATASTORE_CHUNKSIZE); + if (!buf) { + sr_err("session file: %s: buf malloc failed", + __func__); + return SR_ERR_MALLOC; + } + bufcnt = 0; for (d = ds->chunklist; d; d = d->next) { memcpy(buf + bufcnt, d->data, @@ -234,7 +277,8 @@ int sr_session_save(const char *filename) return SR_ERR; if ((ret = zip_close(zipfile)) == -1) { - g_message("error saving zipfile: %s", zip_strerror(zipfile)); + sr_info("session file: error saving zipfile: %s", + zip_strerror(zipfile)); return SR_ERR; }