X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Finput%2Fvcd.c;h=e3c2347ac0875ff6f44f99f000077a691ce3a455;hb=08f8421a9e82;hp=ad0ba7f03d3c839d1b3ee40a862c07fc4ce6826b;hpb=1beccaed464a4d92a070988a0331fe399f9f7a7a;p=libsigrok.git diff --git a/src/input/vcd.c b/src/input/vcd.c index ad0ba7f0..e3c2347a 100644 --- a/src/input/vcd.c +++ b/src/input/vcd.c @@ -26,7 +26,7 @@ * * skip: Allows skipping until given timestamp in the file. * This can speed up analyzing of long captures. - * + * * Value < 0: Skip until first timestamp listed in * the file. (default) * @@ -57,21 +57,22 @@ * - more than 64 channels */ +#include #include #include #include #include -#include "libsigrok.h" +#include #include "libsigrok-internal.h" #define LOG_PREFIX "input/vcd" -#define DEFAULT_NUM_CHANNELS 8 -#define CHUNKSIZE 1024 +#define CHUNK_SIZE (4 * 1024 * 1024) struct context { gboolean started; gboolean got_header; + uint64_t prev_timestamp; uint64_t samplerate; unsigned int maxchannels; unsigned int channelcount; @@ -80,6 +81,11 @@ struct context { int64_t skip; gboolean skip_until_end; GSList *channels; + size_t bytes_per_sample; + size_t samples_in_buffer; + uint8_t *buffer; + uint8_t *current_levels; + GSList *prev_sr_channels; }; struct vcd_channel { @@ -89,7 +95,7 @@ struct vcd_channel { /* * Reads a single VCD section from input file and parses it to name/contents. - * e.g. $timescale 1ps $end => "timescale" "1ps" + * e.g. $timescale 1ps $end => "timescale" "1ps" */ static gboolean parse_section(GString *buf, gchar **name, gchar **contents) { @@ -101,6 +107,10 @@ static gboolean parse_section(GString *buf, gchar **name, gchar **contents) status = FALSE; pos = 0; + /* Skip UTF8 BOM */ + if (buf->len >= 3 && !strncmp(buf->str, "\xef\xbb\xbf", 3)) + pos = 3; + /* Skip any initial white-space. */ while (pos < buf->len && g_ascii_isspace(buf->str[pos])) pos++; @@ -142,7 +152,11 @@ static gboolean parse_section(GString *buf, gchar **name, gchar **contents) static void free_channel(void *data) { - struct vcd_channel *vcd_ch = data; + struct vcd_channel *vcd_ch; + + vcd_ch = data; + if (!vcd_ch) + return; g_free(vcd_ch->name); g_free(vcd_ch->identifier); g_free(vcd_ch); @@ -162,6 +176,56 @@ static void remove_empty_parts(gchar **parts) *dest = NULL; } +/* + * Keep track of a previously created channel list, in preparation of + * re-reading the input file. Gets called from reset()/cleanup() paths. + */ +static void keep_header_for_reread(const struct sr_input *in) +{ + struct context *inc; + + inc = in->priv; + g_slist_free_full(inc->prev_sr_channels, sr_channel_free_cb); + inc->prev_sr_channels = in->sdi->channels; + in->sdi->channels = NULL; +} + +/* + * Check whether the input file is being re-read, and refuse operation + * when essential parameters of the acquisition have changed in ways + * that are unexpected to calling applications. Gets called after the + * file header got parsed (again). + * + * Changing the channel list across re-imports of the same file is not + * supported, by design and for valid reasons, see bug #1215 for details. + * Users are expected to start new sessions when they change these + * essential parameters in the acquisition's setup. When we accept the + * re-read file, then make sure to keep using the previous channel list, + * applications may still reference them. + */ +static int check_header_in_reread(const struct sr_input *in) +{ + struct context *inc; + + if (!in) + return FALSE; + inc = in->priv; + if (!inc) + return FALSE; + if (!inc->prev_sr_channels) + return TRUE; + + if (sr_channel_lists_differ(inc->prev_sr_channels, in->sdi->channels)) { + sr_err("Channel list change not supported for file re-read."); + return FALSE; + } + g_slist_free_full(in->sdi->channels, sr_channel_free_cb); + in->sdi->channels = inc->prev_sr_channels; + inc->prev_sr_channels = NULL; + + return TRUE; +} + /* * Parse VCD header to get values for context structure. * The context structure should be zeroed before calling this. @@ -201,44 +265,64 @@ static gboolean parse_header(const struct sr_input *in, GString *buf) sr_err("Parsing timescale failed."); } } else if (g_strcmp0(name, "var") == 0) { - /* Format: $var type size identifier reference $end */ + /* Format: $var type size identifier reference [opt. index] $end */ + unsigned int length; + parts = g_strsplit_set(contents, " \r\n\t", 0); remove_empty_parts(parts); + length = g_strv_length(parts); - if (g_strv_length(parts) != 4) - sr_warn("$var section should have 4 items"); + if (length != 4 && length != 5) + sr_warn("$var section should have 4 or 5 items"); else if (g_strcmp0(parts[0], "reg") != 0 && g_strcmp0(parts[0], "wire") != 0) sr_info("Unsupported signal type: '%s'", parts[0]); else if (strtol(parts[1], NULL, 10) != 1) sr_info("Unsupported signal size: '%s'", parts[1]); - else if (inc->channelcount >= inc->maxchannels) - sr_warn("Skipping '%s' because only %d channels requested.", - parts[3], inc->maxchannels); + else if (inc->maxchannels && inc->channelcount >= inc->maxchannels) + sr_warn("Skipping '%s%s' because only %d channels requested.", + parts[3], parts[4] ? : "", inc->maxchannels); else { - sr_info("Channel %d is '%s' identified by '%s'.", - inc->channelcount, parts[3], parts[2]); vcd_ch = g_malloc(sizeof(struct vcd_channel)); vcd_ch->identifier = g_strdup(parts[2]); - vcd_ch->name = g_strdup(parts[3]); + if (length == 4) + vcd_ch->name = g_strdup(parts[3]); + else + vcd_ch->name = g_strconcat(parts[3], parts[4], NULL); + + sr_info("Channel %d is '%s' identified by '%s'.", + inc->channelcount, vcd_ch->name, vcd_ch->identifier); + + sr_channel_new(in->sdi, inc->channelcount++, SR_CHANNEL_LOGIC, TRUE, vcd_ch->name); inc->channels = g_slist_append(inc->channels, vcd_ch); - inc->channelcount++; } g_strfreev(parts); } - g_free(name); name = NULL; - g_free(contents); contents = NULL; + g_free(name); + name = NULL; + g_free(contents); + contents = NULL; } g_free(name); g_free(contents); + /* + * Compute how many bytes each sample will have and initialize the + * current levels. The current levels will be updated whenever VCD + * has changes. + */ + inc->bytes_per_sample = (inc->channelcount + 7) / 8; + inc->current_levels = g_malloc0(inc->bytes_per_sample); + inc->got_header = status; + if (status) + status = check_header_in_reread(in); return status; } -static int format_match(GHashTable *metadata) +static int format_match(GHashTable *metadata, unsigned int *confidence) { GString *buf, *tmpbuf; gboolean status; @@ -256,52 +340,100 @@ static int format_match(GHashTable *metadata) g_free(name); g_free(contents); - return status ? SR_OK : SR_ERR; + if (!status) + return SR_ERR; + *confidence = 1; + + return SR_OK; } -/* Send N samples of the given value. */ -static void send_samples(const struct sr_dev_inst *sdi, uint64_t sample, uint64_t count) +/* Send all accumulated bytes from inc->buffer. */ +static void send_buffer(const struct sr_input *in) { + struct context *inc; struct sr_datafeed_packet packet; struct sr_datafeed_logic logic; - uint64_t buffer[CHUNKSIZE]; - uint64_t i; - unsigned chunksize = CHUNKSIZE; - if (count < chunksize) - chunksize = count; + inc = in->priv; - for (i = 0; i < chunksize; i++) - buffer[i] = sample; + if (inc->samples_in_buffer == 0) + return; packet.type = SR_DF_LOGIC; packet.payload = &logic; - logic.unitsize = sizeof(uint64_t); - logic.data = buffer; + logic.unitsize = inc->bytes_per_sample; + logic.data = inc->buffer; + logic.length = inc->bytes_per_sample * inc->samples_in_buffer; + sr_session_send(in->sdi, &packet); + inc->samples_in_buffer = 0; +} + +/* + * Add N copies of the current sample to buffer. + * When the buffer fills up, automatically send it. + */ +static void add_samples(const struct sr_input *in, size_t count) +{ + struct context *inc; + size_t samples_per_chunk; + size_t space_left, i; + uint8_t *p; + + inc = in->priv; + samples_per_chunk = CHUNK_SIZE / inc->bytes_per_sample; while (count) { - if (count < chunksize) - chunksize = count; + space_left = samples_per_chunk - inc->samples_in_buffer; + + if (space_left > count) + space_left = count; + + p = inc->buffer + inc->samples_in_buffer * inc->bytes_per_sample; + for (i = 0; i < space_left; i++) { + memcpy(p, inc->current_levels, inc->bytes_per_sample); + p += inc->bytes_per_sample; + inc->samples_in_buffer++; + count--; + } - logic.length = sizeof(uint64_t) * chunksize; + if (inc->samples_in_buffer == samples_per_chunk) + send_buffer(in); + } +} - sr_session_send(sdi, &packet); - count -= chunksize; +/* Set the channel level depending on the identifier and parsed value. */ +static void process_bit(struct context *inc, char *identifier, unsigned int bit) +{ + GSList *l; + struct vcd_channel *vcd_ch; + unsigned int j; + + for (j = 0, l = inc->channels; j < inc->channelcount && l; j++, l = l->next) { + vcd_ch = l->data; + if (g_strcmp0(identifier, vcd_ch->identifier) == 0) { + /* Found our channel. */ + size_t byte_idx = (j / 8); + size_t bit_idx = j - 8 * byte_idx; + if (bit) + inc->current_levels[byte_idx] |= (uint8_t)1 << bit_idx; + else + inc->current_levels[byte_idx] &= ~((uint8_t)1 << bit_idx); + break; + } } + if (j == inc->channelcount) + sr_dbg("Did not find channel for identifier '%s'.", identifier); } /* Parse a set of lines from the data section. */ static void parse_contents(const struct sr_input *in, char *data) { struct context *inc; - struct vcd_channel *vcd_ch; - GSList *l; - uint64_t timestamp, prev_timestamp, prev_values; - unsigned int bit, i, j; + uint64_t timestamp; + unsigned int bit, i; char **tokens; inc = in->priv; - prev_timestamp = prev_values = 0; /* Read one space-delimited token at a time. */ tokens = g_strsplit_set(data, " \t\r\n", 0); @@ -328,22 +460,26 @@ static void parse_contents(const struct sr_input *in, char *data) */ if (inc->skip < 0) { inc->skip = timestamp; - prev_timestamp = timestamp; + inc->prev_timestamp = timestamp; } else if (inc->skip > 0 && timestamp < (uint64_t)inc->skip) { - prev_timestamp = inc->skip; - } else if (timestamp == prev_timestamp) { + inc->prev_timestamp = inc->skip; + } else if (timestamp == inc->prev_timestamp) { /* Ignore repeated timestamps (e.g. sigrok outputs these) */ + } else if (timestamp < inc->prev_timestamp) { + sr_err("Invalid timestamp: %" PRIu64 " (smaller than previous timestamp).", timestamp); + inc->skip_until_end = TRUE; + break; } else { - if (inc->compress != 0 && timestamp - prev_timestamp > inc->compress) { + if (inc->compress != 0 && timestamp - inc->prev_timestamp > inc->compress) { /* Compress long idle periods */ - prev_timestamp = timestamp - inc->compress; + inc->prev_timestamp = timestamp - inc->compress; } sr_dbg("New timestamp: %" PRIu64, timestamp); /* Generate samples from prev_timestamp up to timestamp - 1. */ - send_samples(in->sdi, prev_values, timestamp - prev_timestamp); - prev_timestamp = timestamp; + add_samples(in, timestamp - inc->prev_timestamp); + inc->prev_timestamp = timestamp; } } else if (tokens[i][0] == '$' && tokens[i][1] != '\0') { /* @@ -360,10 +496,31 @@ static void parse_contents(const struct sr_input *in, char *data) inc->skip_until_end = TRUE; break; } - } else if (strchr("bBrR", tokens[i][0]) != NULL) { - /* A vector value, not supported yet. */ - break; + } else if (strchr("rR", tokens[i][0]) != NULL) { + sr_dbg("Real type vector values not supported yet!"); + if (!tokens[++i]) + /* No tokens left, bail out */ + break; + else + /* Process next token */ + continue; + } else if (strchr("bB", tokens[i][0]) != NULL) { + bit = (tokens[i][1] == '1'); + + /* + * Bail out if a) char after 'b' is NUL, or b) there is + * a second character after 'b', or c) there is no + * identifier. + */ + if (!tokens[i][1] || tokens[i][2] || !tokens[++i]) { + sr_dbg("Unexpected vector format!"); + break; + } + + process_bit(inc, tokens[i], bit); } else if (strchr("01xXzZ", tokens[i][0]) != NULL) { + char *identifier; + /* A new 1-bit sample value */ bit = (tokens[i][0] == '1'); @@ -372,28 +529,15 @@ static void parse_contents(const struct sr_input *in, char *data) * there was whitespace after the bit, the next token. */ if (tokens[i][1] == '\0') { - if (!tokens[++i]) - /* Missing identifier */ - continue; - } else { - for (j = 1; tokens[i][j]; j++) - tokens[i][j - 1] = tokens[i][j]; - tokens[i][j - 1] = '\0'; - } - - for (j = 0, l = inc->channels; j < inc->channelcount && l; j++, l = l->next) { - vcd_ch = l->data; - if (g_strcmp0(tokens[i], vcd_ch->identifier) == 0) { - /* Found our channel */ - if (bit) - prev_values |= (uint64_t)1 << j; - else - prev_values &= ~((uint64_t)1 << j); + if (!tokens[++i]) { + sr_dbg("Identifier missing!"); break; } + identifier = tokens[i]; + } else { + identifier = tokens[i] + 1; } - if (j == inc->channelcount) - sr_dbg("Did not find channel for identifier '%s'.", tokens[i]); + process_bit(inc, identifier, bit); } else { sr_warn("Skipping unknown token '%s'.", tokens[i]); } @@ -403,22 +547,11 @@ static void parse_contents(const struct sr_input *in, char *data) static int init(struct sr_input *in, GHashTable *options) { - int num_channels, i; - char name[16]; struct context *inc; - num_channels = g_variant_get_int32(g_hash_table_lookup(options, "numchannels")); - if (num_channels < 1) { - sr_err("Invalid value for numchannels: must be at least 1."); - return SR_ERR_ARG; - } - if (num_channels > 64) { - sr_err("No more than 64 channels supported."); - return SR_ERR_ARG; - } inc = in->priv = g_malloc0(sizeof(struct context)); - inc->maxchannels = num_channels; + inc->maxchannels = g_variant_get_int32(g_hash_table_lookup(options, "numchannels")); inc->downsample = g_variant_get_int32(g_hash_table_lookup(options, "downsample")); if (inc->downsample < 1) inc->downsample = 1; @@ -430,10 +563,7 @@ static int init(struct sr_input *in, GHashTable *options) in->sdi = g_malloc0(sizeof(struct sr_dev_inst)); in->priv = inc; - for (i = 0; i < num_channels; i++) { - snprintf(name, 16, "%d", i); - sr_channel_new(in->sdi, i, SR_CHANNEL_LOGIC, TRUE, name); - } + inc->buffer = g_malloc(CHUNK_SIZE); return SR_OK; } @@ -465,7 +595,7 @@ static int process_buffer(struct sr_input *in) inc = in->priv; if (!inc->started) { - std_session_send_df_header(in->sdi, LOG_PREFIX); + std_session_send_df_header(in->sdi); packet.type = SR_DF_META; packet.payload = &meta; @@ -473,6 +603,7 @@ static int process_buffer(struct sr_input *in) src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(samplerate)); meta.config = g_slist_append(NULL, src); sr_session_send(in->sdi, &packet); + g_slist_free(meta.config); sr_config_free(src); inc->started = TRUE; @@ -516,20 +647,21 @@ static int receive(struct sr_input *in, GString *buf) static int end(struct sr_input *in) { - struct sr_datafeed_packet packet; struct context *inc; int ret; + inc = in->priv; + if (in->sdi_ready) ret = process_buffer(in); else ret = SR_OK; - inc = in->priv; - if (inc->started) { - packet.type = SR_DF_END; - sr_session_send(in->sdi, &packet); - } + /* Send any samples that haven't been sent yet. */ + send_buffer(in); + + if (inc->started) + std_session_send_df_end(in->sdi); return ret; } @@ -539,21 +671,47 @@ static void cleanup(struct sr_input *in) struct context *inc; inc = in->priv; + keep_header_for_reread(in); g_slist_free_full(inc->channels, free_channel); + inc->channels = NULL; + + g_free(inc->buffer); + inc->buffer = NULL; + g_free(inc->current_levels); + inc->current_levels = NULL; +} + +static int reset(struct sr_input *in) +{ + struct context *inc = in->priv; + + cleanup(in); + g_string_truncate(in->buf, 0); + + inc->started = FALSE; + inc->got_header = FALSE; + inc->prev_timestamp = 0; + inc->skip_until_end = FALSE; + inc->channelcount = 0; + /* The inc->channels list was released in cleanup() above. */ + inc->buffer = g_malloc(CHUNK_SIZE); + + return SR_OK; } static struct sr_option options[] = { - { "numchannels", "Number of channels", "Number of channels", NULL, NULL }, - { "skip", "Skip", "Skip until timestamp", NULL, NULL }, - { "downsample", "Downsample", "Divide samplerate by factor", NULL, NULL }, - { "compress", "Compress", "Compress idle periods longer than this value", NULL, NULL }, + { "numchannels", "Number of logic channels", "The number of (logic) channels in the data", NULL, NULL }, + { "skip", "Skip samples until timestamp", "Skip samples until the specified timestamp; " + "< 0: Skip until first timestamp listed; 0: Don't skip", NULL, NULL }, + { "downsample", "Downsampling factor", "Downsample, i.e. divide the samplerate by the specified factor", NULL, NULL }, + { "compress", "Compress idle periods", "Compress idle periods longer than the specified value", NULL, NULL }, ALL_ZERO }; -static struct sr_option *get_options(void) +static const struct sr_option *get_options(void) { if (!options[0].def) { - options[0].def = g_variant_ref_sink(g_variant_new_int32(DEFAULT_NUM_CHANNELS)); + options[0].def = g_variant_ref_sink(g_variant_new_int32(0)); options[1].def = g_variant_ref_sink(g_variant_new_int32(-1)); options[2].def = g_variant_ref_sink(g_variant_new_int32(1)); options[3].def = g_variant_ref_sink(g_variant_new_int32(0)); @@ -565,7 +723,7 @@ static struct sr_option *get_options(void) SR_PRIV struct sr_input_module input_vcd = { .id = "vcd", .name = "VCD", - .desc = "Value Change Dump", + .desc = "Value Change Dump data", .exts = (const char*[]){"vcd", NULL}, .metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED }, .options = get_options, @@ -574,4 +732,5 @@ SR_PRIV struct sr_input_module input_vcd = { .receive = receive, .end = end, .cleanup = cleanup, + .reset = reset, };