2 * This file is part of the libsigrok project.
4 * Copyright (C) 2012 Petteri Aimonen <jpa@sr.mail.kapsi.fi>
5 * Copyright (C) 2014 Bert Vermeulen <bert@biot.com>
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 /* The VCD input module has the following options:
23 * numchannels: Maximum number of channels to use. The channels are
24 * detected in the same order as they are listed
25 * in the $var sections of the VCD file.
27 * skip: Allows skipping until given timestamp in the file.
28 * This can speed up analyzing of long captures.
30 * Value < 0: Skip until first timestamp listed in
33 * Value = 0: Do not skip, instead generate samples
34 * beginning from timestamp 0.
36 * Value > 0: Start at the given timestamp.
38 * downsample: Divide the samplerate by the given factor.
39 * This can speed up analyzing of long captures.
41 * compress: Compress idle periods longer than this value.
42 * This can speed up analyzing of long captures.
43 * Default 0 = don't compress.
45 * Based on Verilog standard IEEE Std 1364-2001 Version C
48 * - $var with 'wire' and 'reg' types of scalar variables
49 * - $timescale definition for samplerate
50 * - multiple character variable identifiers
52 * Most important unsupported features:
53 * - vector variables (bit vectors etc.)
54 * - analog, integer and real number variables
55 * - $dumpvars initial value declaration
57 * - more than 64 channels
65 #include <libsigrok/libsigrok.h>
66 #include "libsigrok-internal.h"
68 #define LOG_PREFIX "input/vcd"
70 #define CHUNK_SIZE (4 * 1024 * 1024)
75 uint64_t prev_timestamp;
77 unsigned int maxchannels;
78 unsigned int channelcount;
82 gboolean skip_until_end;
84 size_t bytes_per_sample;
85 size_t samples_in_buffer;
87 uint8_t *current_levels;
88 GSList *prev_sr_channels;
97 * Reads a single VCD section from input file and parses it to name/contents.
98 * e.g. $timescale 1ps $end => "timescale" "1ps"
100 static gboolean parse_section(GString *buf, gchar **name, gchar **contents)
102 GString *sname, *scontent;
106 *name = *contents = NULL;
111 if (buf->len >= 3 && !strncmp(buf->str, "\xef\xbb\xbf", 3))
114 /* Skip any initial white-space. */
115 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
118 /* Section tag should start with $. */
119 if (buf->str[pos++] != '$')
122 sname = g_string_sized_new(32);
123 scontent = g_string_sized_new(128);
125 /* Read the section tag. */
126 while (pos < buf->len && !g_ascii_isspace(buf->str[pos]))
127 g_string_append_c(sname, buf->str[pos++]);
129 /* Skip whitespace before content. */
130 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
133 /* Read the content. */
134 while (pos < buf->len - 4 && strncmp(buf->str + pos, "$end", 4))
135 g_string_append_c(scontent, buf->str[pos++]);
137 if (sname->len && pos < buf->len - 4 && !strncmp(buf->str + pos, "$end", 4)) {
140 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
142 g_string_erase(buf, 0, pos);
145 *name = g_string_free(sname, !status);
146 *contents = g_string_free(scontent, !status);
148 g_strchomp(*contents);
153 static void free_channel(void *data)
155 struct vcd_channel *vcd_ch;
160 g_free(vcd_ch->name);
161 g_free(vcd_ch->identifier);
165 /* Remove empty parts from an array returned by g_strsplit. */
166 static void remove_empty_parts(gchar **parts)
169 gchar **dest = parts;
170 while (*src != NULL) {
180 * Keep track of a previously created channel list, in preparation of
181 * re-reading the input file. Gets called from reset()/cleanup() paths.
183 static void keep_header_for_reread(const struct sr_input *in)
188 g_slist_free_full(inc->prev_sr_channels, sr_channel_free_cb);
189 inc->prev_sr_channels = in->sdi->channels;
190 in->sdi->channels = NULL;
194 * Check whether the input file is being re-read, and refuse operation
195 * when essential parameters of the acquisition have changed in ways
196 * that are unexpected to calling applications. Gets called after the
197 * file header got parsed (again).
199 * Changing the channel list across re-imports of the same file is not
200 * supported, by design and for valid reasons, see bug #1215 for details.
201 * Users are expected to start new sessions when they change these
202 * essential parameters in the acquisition's setup. When we accept the
203 * re-read file, then make sure to keep using the previous channel list,
204 * applications may still reference them.
206 static int check_header_in_reread(const struct sr_input *in)
215 if (!inc->prev_sr_channels)
218 if (sr_channel_lists_differ(inc->prev_sr_channels, in->sdi->channels)) {
219 sr_err("Channel list change not supported for file re-read.");
222 g_slist_free_full(in->sdi->channels, sr_channel_free_cb);
223 in->sdi->channels = inc->prev_sr_channels;
224 inc->prev_sr_channels = NULL;
230 * Parse VCD header to get values for context structure.
231 * The context structure should be zeroed before calling this.
233 static gboolean parse_header(const struct sr_input *in, GString *buf)
235 struct vcd_channel *vcd_ch;
239 gchar *name, *contents, **parts;
242 name = contents = NULL;
244 while (parse_section(buf, &name, &contents)) {
245 sr_dbg("Section '%s', contents '%s'.", name, contents);
247 if (g_strcmp0(name, "enddefinitions") == 0) {
250 } else if (g_strcmp0(name, "timescale") == 0) {
252 * The standard allows for values 1, 10 or 100
253 * and units s, ms, us, ns, ps and fs.
255 if (sr_parse_period(contents, &p, &q) == SR_OK) {
256 inc->samplerate = q / p;
258 /* Does not happen unless time value is non-standard */
259 sr_warn("Inexact rounding of samplerate, %" PRIu64 " / %" PRIu64 " to %" PRIu64 " Hz.",
260 q, p, inc->samplerate);
263 sr_dbg("Samplerate: %" PRIu64, inc->samplerate);
265 sr_err("Parsing timescale failed.");
267 } else if (g_strcmp0(name, "var") == 0) {
268 /* Format: $var type size identifier reference [opt. index] $end */
271 parts = g_strsplit_set(contents, " \r\n\t", 0);
272 remove_empty_parts(parts);
273 length = g_strv_length(parts);
275 if (length != 4 && length != 5)
276 sr_warn("$var section should have 4 or 5 items");
277 else if (g_strcmp0(parts[0], "reg") != 0 && g_strcmp0(parts[0], "wire") != 0)
278 sr_info("Unsupported signal type: '%s'", parts[0]);
279 else if (strtol(parts[1], NULL, 10) != 1)
280 sr_info("Unsupported signal size: '%s'", parts[1]);
281 else if (inc->maxchannels && inc->channelcount >= inc->maxchannels)
282 sr_warn("Skipping '%s%s' because only %d channels requested.",
283 parts[3], parts[4] ? : "", inc->maxchannels);
285 vcd_ch = g_malloc(sizeof(struct vcd_channel));
286 vcd_ch->identifier = g_strdup(parts[2]);
288 vcd_ch->name = g_strdup(parts[3]);
290 vcd_ch->name = g_strconcat(parts[3], parts[4], NULL);
292 sr_info("Channel %d is '%s' identified by '%s'.",
293 inc->channelcount, vcd_ch->name, vcd_ch->identifier);
295 sr_channel_new(in->sdi, inc->channelcount++, SR_CHANNEL_LOGIC, TRUE, vcd_ch->name);
296 inc->channels = g_slist_append(inc->channels, vcd_ch);
311 * Compute how many bytes each sample will have and initialize the
312 * current levels. The current levels will be updated whenever VCD
315 inc->bytes_per_sample = (inc->channelcount + 7) / 8;
316 inc->current_levels = g_malloc0(inc->bytes_per_sample);
318 inc->got_header = status;
320 status = check_header_in_reread(in);
325 static int format_match(GHashTable *metadata, unsigned int *confidence)
327 GString *buf, *tmpbuf;
329 gchar *name, *contents;
331 buf = g_hash_table_lookup(metadata, GINT_TO_POINTER(SR_INPUT_META_HEADER));
332 tmpbuf = g_string_new_len(buf->str, buf->len);
335 * If we can parse the first section correctly,
336 * then it is assumed to be a VCD file.
338 status = parse_section(tmpbuf, &name, &contents);
339 g_string_free(tmpbuf, TRUE);
350 /* Send all accumulated bytes from inc->buffer. */
351 static void send_buffer(const struct sr_input *in)
354 struct sr_datafeed_packet packet;
355 struct sr_datafeed_logic logic;
359 if (inc->samples_in_buffer == 0)
362 packet.type = SR_DF_LOGIC;
363 packet.payload = &logic;
364 logic.unitsize = inc->bytes_per_sample;
365 logic.data = inc->buffer;
366 logic.length = inc->bytes_per_sample * inc->samples_in_buffer;
367 sr_session_send(in->sdi, &packet);
368 inc->samples_in_buffer = 0;
372 * Add N copies of the current sample to buffer.
373 * When the buffer fills up, automatically send it.
375 static void add_samples(const struct sr_input *in, size_t count)
378 size_t samples_per_chunk;
379 size_t space_left, i;
383 samples_per_chunk = CHUNK_SIZE / inc->bytes_per_sample;
386 space_left = samples_per_chunk - inc->samples_in_buffer;
388 if (space_left > count)
391 p = inc->buffer + inc->samples_in_buffer * inc->bytes_per_sample;
392 for (i = 0; i < space_left; i++) {
393 memcpy(p, inc->current_levels, inc->bytes_per_sample);
394 p += inc->bytes_per_sample;
395 inc->samples_in_buffer++;
399 if (inc->samples_in_buffer == samples_per_chunk)
404 /* Set the channel level depending on the identifier and parsed value. */
405 static void process_bit(struct context *inc, char *identifier, unsigned int bit)
408 struct vcd_channel *vcd_ch;
411 for (j = 0, l = inc->channels; j < inc->channelcount && l; j++, l = l->next) {
413 if (g_strcmp0(identifier, vcd_ch->identifier) == 0) {
414 /* Found our channel. */
415 size_t byte_idx = (j / 8);
416 size_t bit_idx = j - 8 * byte_idx;
418 inc->current_levels[byte_idx] |= (uint8_t)1 << bit_idx;
420 inc->current_levels[byte_idx] &= ~((uint8_t)1 << bit_idx);
424 if (j == inc->channelcount)
425 sr_dbg("Did not find channel for identifier '%s'.", identifier);
428 /* Parse a set of lines from the data section. */
429 static void parse_contents(const struct sr_input *in, char *data)
438 /* Read one space-delimited token at a time. */
439 tokens = g_strsplit_set(data, " \t\r\n", 0);
440 remove_empty_parts(tokens);
441 for (i = 0; tokens[i]; i++) {
442 if (inc->skip_until_end) {
443 if (!strcmp(tokens[i], "$end")) {
444 /* Done with unhandled/unknown section. */
445 inc->skip_until_end = FALSE;
449 if (tokens[i][0] == '#' && g_ascii_isdigit(tokens[i][1])) {
450 /* Numeric value beginning with # is a new timestamp value */
451 timestamp = strtoull(tokens[i] + 1, NULL, 10);
453 if (inc->downsample > 1)
454 timestamp /= inc->downsample;
457 * Skip < 0 => skip until first timestamp.
458 * Skip = 0 => don't skip
459 * Skip > 0 => skip until timestamp >= skip.
462 inc->skip = timestamp;
463 inc->prev_timestamp = timestamp;
464 } else if (inc->skip > 0 && timestamp < (uint64_t)inc->skip) {
465 inc->prev_timestamp = inc->skip;
466 } else if (timestamp == inc->prev_timestamp) {
467 /* Ignore repeated timestamps (e.g. sigrok outputs these) */
468 } else if (timestamp < inc->prev_timestamp) {
469 sr_err("Invalid timestamp: %" PRIu64 " (smaller than previous timestamp).", timestamp);
470 inc->skip_until_end = TRUE;
473 if (inc->compress != 0 && timestamp - inc->prev_timestamp > inc->compress) {
474 /* Compress long idle periods */
475 inc->prev_timestamp = timestamp - inc->compress;
478 sr_dbg("New timestamp: %" PRIu64, timestamp);
480 /* Generate samples from prev_timestamp up to timestamp - 1. */
481 add_samples(in, timestamp - inc->prev_timestamp);
482 inc->prev_timestamp = timestamp;
484 } else if (tokens[i][0] == '$' && tokens[i][1] != '\0') {
486 * This is probably a $dumpvars, $comment or similar.
487 * $dump* contain useful data.
489 if (g_strcmp0(tokens[i], "$dumpvars") == 0
490 || g_strcmp0(tokens[i], "$dumpon") == 0
491 || g_strcmp0(tokens[i], "$dumpoff") == 0
492 || g_strcmp0(tokens[i], "$end") == 0) {
493 /* Ignore, parse contents as normally. */
495 /* Ignore this and future lines until $end. */
496 inc->skip_until_end = TRUE;
499 } else if (strchr("rR", tokens[i][0]) != NULL) {
500 sr_dbg("Real type vector values not supported yet!");
502 /* No tokens left, bail out */
505 /* Process next token */
507 } else if (strchr("bB", tokens[i][0]) != NULL) {
508 bit = (tokens[i][1] == '1');
511 * Bail out if a) char after 'b' is NUL, or b) there is
512 * a second character after 'b', or c) there is no
515 if (!tokens[i][1] || tokens[i][2] || !tokens[++i]) {
516 sr_dbg("Unexpected vector format!");
520 process_bit(inc, tokens[i], bit);
521 } else if (strchr("01xXzZ", tokens[i][0]) != NULL) {
524 /* A new 1-bit sample value */
525 bit = (tokens[i][0] == '1');
528 * The identifier is either the next character, or, if
529 * there was whitespace after the bit, the next token.
531 if (tokens[i][1] == '\0') {
533 sr_dbg("Identifier missing!");
536 identifier = tokens[i];
538 identifier = tokens[i] + 1;
540 process_bit(inc, identifier, bit);
542 sr_warn("Skipping unknown token '%s'.", tokens[i]);
548 static int init(struct sr_input *in, GHashTable *options)
552 inc = in->priv = g_malloc0(sizeof(struct context));
554 inc->maxchannels = g_variant_get_int32(g_hash_table_lookup(options, "numchannels"));
555 inc->downsample = g_variant_get_int32(g_hash_table_lookup(options, "downsample"));
556 if (inc->downsample < 1)
559 inc->compress = g_variant_get_int32(g_hash_table_lookup(options, "compress"));
560 inc->skip = g_variant_get_int32(g_hash_table_lookup(options, "skip"));
561 inc->skip /= inc->downsample;
563 in->sdi = g_malloc0(sizeof(struct sr_dev_inst));
566 inc->buffer = g_malloc(CHUNK_SIZE);
571 static gboolean have_header(GString *buf)
576 if (!(p = g_strstr_len(buf->str, buf->len, "$enddefinitions")))
578 pos = p - buf->str + 15;
579 while (pos < buf->len - 4 && g_ascii_isspace(buf->str[pos]))
581 if (!strncmp(buf->str + pos, "$end", 4))
587 static int process_buffer(struct sr_input *in)
589 struct sr_datafeed_packet packet;
590 struct sr_datafeed_meta meta;
591 struct sr_config *src;
598 std_session_send_df_header(in->sdi);
600 packet.type = SR_DF_META;
601 packet.payload = &meta;
602 samplerate = inc->samplerate / inc->downsample;
603 src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(samplerate));
604 meta.config = g_slist_append(NULL, src);
605 sr_session_send(in->sdi, &packet);
606 g_slist_free(meta.config);
612 while ((p = g_strrstr_len(in->buf->str, in->buf->len, "\n"))) {
614 g_strstrip(in->buf->str);
615 if (in->buf->str[0] != '\0')
616 parse_contents(in, in->buf->str);
617 g_string_erase(in->buf, 0, p - in->buf->str + 1);
623 static int receive(struct sr_input *in, GString *buf)
628 g_string_append_len(in->buf, buf->str, buf->len);
631 if (!inc->got_header) {
632 if (!have_header(in->buf))
634 if (!parse_header(in, in->buf))
635 /* There was a header in there, but it was malformed. */
638 in->sdi_ready = TRUE;
639 /* sdi is ready, notify frontend. */
643 ret = process_buffer(in);
648 static int end(struct sr_input *in)
656 ret = process_buffer(in);
660 /* Send any samples that haven't been sent yet. */
664 std_session_send_df_end(in->sdi);
669 static void cleanup(struct sr_input *in)
674 keep_header_for_reread(in);
675 g_slist_free_full(inc->channels, free_channel);
676 inc->channels = NULL;
680 g_free(inc->current_levels);
681 inc->current_levels = NULL;
684 static int reset(struct sr_input *in)
686 struct context *inc = in->priv;
689 g_string_truncate(in->buf, 0);
691 inc->started = FALSE;
692 inc->got_header = FALSE;
693 inc->prev_timestamp = 0;
694 inc->skip_until_end = FALSE;
695 inc->channelcount = 0;
696 /* The inc->channels list was released in cleanup() above. */
697 inc->buffer = g_malloc(CHUNK_SIZE);
702 static struct sr_option options[] = {
703 { "numchannels", "Number of logic channels", "The number of (logic) channels in the data", NULL, NULL },
704 { "skip", "Skip samples until timestamp", "Skip samples until the specified timestamp; "
705 "< 0: Skip until first timestamp listed; 0: Don't skip", NULL, NULL },
706 { "downsample", "Downsampling factor", "Downsample, i.e. divide the samplerate by the specified factor", NULL, NULL },
707 { "compress", "Compress idle periods", "Compress idle periods longer than the specified value", NULL, NULL },
711 static const struct sr_option *get_options(void)
713 if (!options[0].def) {
714 options[0].def = g_variant_ref_sink(g_variant_new_int32(0));
715 options[1].def = g_variant_ref_sink(g_variant_new_int32(-1));
716 options[2].def = g_variant_ref_sink(g_variant_new_int32(1));
717 options[3].def = g_variant_ref_sink(g_variant_new_int32(0));
723 SR_PRIV struct sr_input_module input_vcd = {
726 .desc = "Value Change Dump data",
727 .exts = (const char*[]){"vcd", NULL},
728 .metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
729 .options = get_options,
730 .format_match = format_match,