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>
6 * Copyright (C) 2017-2020 Gerhard Sittig <gerhard.sittig@gmx.net>
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
23 * The VCD input module has the following options. See the options[]
24 * declaration near the bottom of the input module's source file.
26 * numchannels: Maximum number of sigrok channels to create. VCD signals
27 * are detected in their order of declaration in the VCD file header,
28 * and mapped to sigrok channels.
30 * skip: Allows to skip data at the start of the input file. This can
31 * speed up operation on long captures.
32 * Value < 0: Skip until first timestamp that is listed in the file.
33 * (This is the default behaviour.)
34 * Value = 0: Do not skip, instead generate samples beginning from
36 * Value > 0: Start at the given timestamp.
38 * downsample: Divide the samplerate by the given factor. This can
39 * speed up operation on long captures.
41 * compress: Trim idle periods which are longer than this value to span
42 * only this many timescale ticks. This can speed up operation on long
43 * captures (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
51 * - same identifer used for multiple signals (identical values)
52 * - vector variables (bit vectors)
53 * - integer variables (analog signals with 0 digits, passed as single
54 * precision float number)
55 * - real variables (analog signals, passed on with single precision,
56 * arbitrary digits value, not user adjustable)
57 * - nested $scope, results in prefixed sigrok channel names
59 * Most important unsupported features:
60 * - $dumpvars initial value declaration (is not an issue if generators
61 * provide sample data for the #0 timestamp, otherwise session data
62 * starts from zero values, and catches up when the signal changes its
63 * state to a supported value)
65 * Implementor's note: This input module specifically does _not_ use
66 * glib routines where they would hurt performance. Lots of memory
67 * allocations increase execution time not by percents but by huge
68 * factors. This motivated this module's custom code for splitting
69 * words on text lines, and pooling previously allocated buffers.
71 * TODO (in arbitrary order)
72 * - Map VCD scopes to sigrok channel groups?
73 * - Does libsigrok support nested channel groups? Or is this feature
74 * exclusive to Pulseview?
75 * - Check VCD input to VCD output behaviour. Verify that export and
76 * re-import results in identical data (well, VCD's constraints on
77 * timescale values is known to result in differences).
78 * - Check the minimum timestamp delta in the input data set, suggest
79 * the downsample=N option to users for reduced resource consumption.
80 * Popular VCD file creation utilities love to specify insanely tiny
81 * timescale values in the pico or even femto seconds range. Which
82 * results in huge sample counts after import, and potentially even
83 * terminates the application due to resource exhaustion. This issue
84 * only will vanish when common libsigrok infrastructure no longer
85 * depends on constant rate streams of samples at discrete points
86 * in time. The current input module implementation has code in place
87 * to gather timestamp statistics, but the most appropriate condition
88 * when to notify users is yet to be found.
89 * - Cleanup the implementation.
90 * - Consistent use of the glib API (where appropriate).
91 * - More appropriate variable/function identifiers.
92 * - More robust handling of multi-word input phrases and chunked
93 * input buffers? This implementation assumes that e.g. b[01]+
94 * patterns are complete when they start, and the signal identifier
95 * is available as well. Which may be true assuming that input data
96 * comes in complete text lines.
97 * - See if other input modules have learned lessons that we could
98 * benefit from here as well? Pointless BOM (done), line oriented
99 * processing with EOL variants and with optional last EOL, module
100 * state reset and file re-read (stable channels list), buffered
101 * session feed, synchronized feed for mixed signal sources, digits
102 * or formats support for analog input, single vs double precision,
104 * - Re-consider logging. Verbosity levels should be acceptable,
105 * but volume is an issue. Drop duplicates, and drop messages from
106 * known good code paths.
112 #include <libsigrok/libsigrok.h>
113 #include "libsigrok-internal.h"
118 #define LOG_PREFIX "input/vcd"
120 #define CHUNK_SIZE (4 * 1024 * 1024)
121 #define SCOPE_SEP '.'
124 struct vcd_user_opt {
125 size_t maxchannels; /* sigrok channels (output) */
128 uint64_t skip_starttime;
129 gboolean skip_specified;
134 uint64_t prev_timestamp;
136 size_t vcdsignals; /* VCD signals (input) */
137 GSList *ignored_signals;
138 gboolean data_after_timestamp;
139 gboolean ignore_end_keyword;
140 gboolean skip_until_end;
145 uint8_t *current_logic;
146 float *current_floats;
153 GString *scope_prefix;
154 struct feed_queue_logic *feed_logic;
161 size_t total_ts_seen;
162 uint64_t last_ts_value;
163 uint64_t last_ts_delta;
169 uint32_t early_check_shift;
170 size_t early_last_emitted;
182 enum sr_channeltype type;
187 size_t range_lower, range_upper;
189 struct feed_queue_analog *feed_analog;
192 static void free_channel(void *data)
194 struct vcd_channel *vcd_ch;
200 g_free(vcd_ch->name);
201 g_free(vcd_ch->identifier);
202 g_free(vcd_ch->base_name);
203 feed_queue_analog_free(vcd_ch->feed_analog);
208 /* TODO Drop the local decl when this has become a common helper. */
209 void sr_channel_group_free(struct sr_channel_group *cg);
211 /* Wrapper for GDestroyNotify compatibility. */
212 static void cg_free(void *p)
214 sr_channel_group_free(p);
218 * Another timestamp delta was observed, update statistics: Update the
219 * sorted list of minimum values, and increment the occurance counter.
220 * Returns the position of the item's statistics slot, or returns a huge
221 * invalid index when the current delta is larger than previously found
224 static size_t ts_stats_update_min(struct ts_stats *stats, uint64_t delta)
226 size_t idx, copy_idx;
228 /* Advance over previously recorded values which are smaller. */
230 while (idx < stats->min_count && stats->min_items[idx].delta < delta)
232 if (idx == ARRAY_SIZE(stats->min_items))
235 /* Found the exact value that previously was registered? */
236 if (stats->min_items[idx].delta == delta) {
237 stats->min_items[idx].count++;
241 /* Allocate another slot, bubble up larger values as needed. */
242 if (stats->min_count < ARRAY_SIZE(stats->min_items))
244 for (copy_idx = stats->min_count - 1; copy_idx > idx; copy_idx--)
245 stats->min_items[copy_idx] = stats->min_items[copy_idx - 1];
247 /* Start tracking this value in the found or freed slot. */
248 memset(&stats->min_items[idx], 0, sizeof(stats->min_items[idx]));
249 stats->min_items[idx].delta = delta;
250 stats->min_items[idx].count++;
256 * Intermediate check for extreme oversampling in the input data. Rate
257 * limited emission of warnings to avoid noise, "late" emission of the
258 * first potential message to avoid false positives, yet need to emit
259 * the messages early (*way* before EOF) to raise awareness.
262 * Tune the limits, improve perception and usefulness of these checks.
263 * Need to start emitting messages soon enough to be seen by users. Yet
264 * avoid unnecessary messages for valid input's idle/quiet phases. Slow
265 * input transitions are perfectly legal before bursty phases are seen
266 * in the input data. Needs the check become an option, on by default,
267 * but suppressable by users?
269 static void ts_stats_check_early(struct ts_stats *stats)
271 static const struct {
274 } *cp, check_points[] = {
275 { 100, 1000000, }, /* Still x100 after 1mio transitions. */
276 { 1000, 100000, }, /* Still x1k after 100k transitions. */
277 { 10000, 10000, }, /* Still x10k after 10k transitions. */
278 { 1000000, 2500, }, /* Still x1m after 2.5k transitions. */
282 uint64_t seen_delta, check_delta;
285 /* Get the current minimum's value and count. */
286 if (!stats->min_count)
288 seen_delta = stats->min_items[0].delta;
289 seen_count = stats->min_items[0].count;
291 /* Emit at most one weak message per import. */
292 if (stats->early_last_emitted)
295 /* Check arbitrary marks, emit rate limited warnings. */
297 check_delta = seen_delta >> stats->early_check_shift;
298 for (cp_idx = 0; cp_idx < ARRAY_SIZE(check_points); cp_idx++) {
299 cp = &check_points[cp_idx];
300 /* No other match can happen below. Done iterating. */
301 if (stats->total_ts_seen > cp->count)
303 /* Advance to the next checkpoint description. */
304 if (stats->total_ts_seen != cp->count)
306 /* First occurance of that timestamp count. Check the value. */
307 sr_dbg("TS early chk: total %" PRIu64 ", min delta %zu / %zu.",
308 cp->count, seen_delta, check_delta);
309 if (check_delta < cp->delta)
311 sr_warn("Low change rate? (weak estimate, min TS delta %" PRIu64 " after %zu timestamps)",
312 seen_delta, stats->total_ts_seen);
313 sr_warn("Consider using the downsample=N option, or increasing its value.");
314 stats->early_last_emitted = stats->total_ts_seen;
319 /* Reset the internal state of the timestamp tracker. */
320 static int ts_stats_prep(struct context *inc)
322 struct ts_stats *stats;
323 uint64_t down_sample_value;
324 uint32_t down_sample_shift;
326 stats = &inc->ts_stats;
327 memset(stats, 0, sizeof(*stats));
329 down_sample_value = inc->options.downsample;
330 down_sample_shift = 0;
331 while (down_sample_value >= 2) {
333 down_sample_value /= 2;
335 stats->early_check_shift = down_sample_shift;
340 /* Inspect another timestamp that was received. */
341 static int ts_stats_check(struct ts_stats *stats, uint64_t curr_ts)
343 uint64_t last_ts, delta;
345 last_ts = stats->last_ts_value;
346 stats->last_ts_value = curr_ts;
347 stats->total_ts_seen++;
348 if (stats->total_ts_seen < 2)
351 delta = curr_ts - last_ts;
352 stats->last_ts_delta = delta;
353 (void)ts_stats_update_min(stats, delta);
355 ts_stats_check_early(stats);
360 /* Postprocess internal timestamp tracker state. */
361 static int ts_stats_post(struct context *inc, gboolean ignore_terminal)
363 struct ts_stats *stats;
365 uint64_t delta, over_sample, over_sample_scaled, suggest_factor;
366 enum sr_loglevel log_level;
367 gboolean is_suspicious, has_downsample;
369 stats = &inc->ts_stats;
372 * Lookup the smallest timestamp delta which was found during
373 * data import. Ignore the last delta if its timestamp was never
374 * followed by data, and this was the only occurance. Absence of
375 * result data is non-fatal here -- this code exclusively serves
376 * to raise users' awareness of potential pitfalls, but does not
377 * change behaviour of data processing.
379 * TODO Also filter by occurance count? To not emit warnings when
380 * captured signals only change slowly by design. Only warn when
381 * the sample rate and samples count product exceeds a threshold?
382 * See below for the necessity (and potential) to adjust the log
383 * message's severity and content.
386 if (ignore_terminal) do {
387 if (min_idx >= stats->min_count)
389 delta = stats->last_ts_delta;
390 if (stats->min_items[min_idx].delta != delta)
392 if (stats->min_items[min_idx].count != 1)
396 if (min_idx >= stats->min_count)
400 * TODO Refine the condition whether to notify the user, and
401 * which severity to use after having inspected all input data.
402 * Any detail could get involved which previously was gathered
403 * during data processing: total sample count, channel count
404 * including their data type and bits width, the oversampling
405 * factor (minimum observed "change rate"), or any combination
406 * thereof. The current check is rather simple (unconditional
407 * warning for ratios starting at 100, regardless of sample or
410 over_sample = stats->min_items[min_idx].delta;
411 over_sample_scaled = over_sample / inc->options.downsample;
412 sr_dbg("TS post stats: oversample unscaled %" PRIu64 ", scaled %" PRIu64,
413 over_sample, over_sample_scaled);
414 if (over_sample_scaled < 10) {
415 sr_dbg("TS post stats: Low oversampling ratio, good.");
420 * Avoid constructing the message from several tiny pieces by
421 * design, because this would be hard on translators. Stick with
422 * complete sentences instead, and accept the redundancy in the
425 log_level = (over_sample_scaled > 20) ? SR_LOG_WARN : SR_LOG_INFO;
426 is_suspicious = over_sample_scaled > 20;
428 sr_log(log_level, LOG_PREFIX ": "
429 "Suspiciously low overall change rate (total min TS delta %" PRIu64 ").",
432 sr_log(log_level, LOG_PREFIX ": "
433 "Low overall change rate (total min TS delta %" PRIu64 ").",
436 has_downsample = inc->options.downsample > 1;
437 suggest_factor = inc->options.downsample;
438 while (over_sample_scaled >= 10) {
439 suggest_factor *= 10;
440 over_sample_scaled /= 10;
442 if (has_downsample) {
443 sr_log(log_level, LOG_PREFIX ": "
444 "Suggest higher downsample value, like %" PRIu64 ".",
447 sr_log(log_level, LOG_PREFIX ": "
448 "Suggest to downsample, value like %" PRIu64 ".",
455 static void check_remove_bom(GString *buf)
457 static const char *bom_text = "\xef\xbb\xbf";
459 if (buf->len < strlen(bom_text))
461 if (strncmp(buf->str, bom_text, strlen(bom_text)) != 0)
463 g_string_erase(buf, 0, strlen(bom_text));
467 * Reads a single VCD section from input file and parses it to name/contents.
468 * e.g. $timescale 1ps $end => "timescale" "1ps"
470 static gboolean parse_section(GString *buf, char **name, char **contents)
472 static const char *end_text = "$end";
476 const char *grab_start, *grab_end;
477 GString *sname, *scontent;
479 /* Preset falsy return values. Gets updated below. */
480 *name = *contents = NULL;
483 /* Skip any initial white-space. */
485 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
488 /* Section tag should start with $. */
489 if (buf->str[pos++] != '$')
492 /* Read the section tag. */
493 grab_start = &buf->str[pos];
494 while (pos < buf->len && !g_ascii_isspace(buf->str[pos]))
496 grab_end = &buf->str[pos];
497 sname = g_string_new_len(grab_start, grab_end - grab_start);
499 /* Skip whitespace before content. */
500 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
503 /* Read the content up to the '$end' marker. */
504 scontent = g_string_sized_new(128);
505 grab_start = &buf->str[pos];
506 grab_end = g_strstr_len(grab_start, buf->len - pos, end_text);
508 /* Advance 'pos' to after '$end' and more whitespace. */
509 pos = grab_end - buf->str;
510 pos += strlen(end_text);
511 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
514 /* Grab the (trimmed) content text. */
515 while (grab_end > grab_start && g_ascii_isspace(grab_end[-1]))
517 len = grab_end - grab_start;
518 g_string_append_len(scontent, grab_start, len);
522 /* Consume the input text which just was taken. */
523 g_string_erase(buf, 0, pos);
526 /* Return section name and content if a section was seen. */
527 *name = g_string_free(sname, !status);
528 *contents = g_string_free(scontent, !status);
534 * The glib routine which splits an input text into a list of words also
535 * "provides empty strings" which application code then needs to remove.
536 * And copies of the input text get allocated for all words.
538 * The repeated memory allocation is acceptable for small workloads like
539 * parsing the header sections. But the heavy lifting for sample data is
540 * done by DIY code to speedup execution. The use of glib routines would
541 * severely hurt throughput. Allocated memory gets re-used while a strict
542 * ping-pong pattern is assumed (each text line of input data enters and
543 * leaves in a strict symmetrical manner, due to the organization of the
544 * receive() routine and parse calls).
547 /* Remove empty parts from an array returned by g_strsplit(). */
548 static void remove_empty_parts(gchar **parts)
566 static char **split_text_line(struct context *inc, char *text, size_t *count)
568 struct split_state *state;
569 size_t counted, alloced, wanted;
570 char **words, *p, **new_words;
578 sr_dbg("coding error, split() called while \"in use\".");
583 * Seed allocation when invoked for the first time. Assume
584 * simple logic data, start with a few words per line. Will
585 * automatically adjust with subsequent use.
587 if (!state->alloced) {
589 words = g_malloc(sizeof(words[0]) * alloced);
592 state->alloced = alloced;
593 state->words = words;
596 /* Start with most recently allocated word list space. */
597 alloced = state->alloced;
598 words = state->words;
601 /* As long as more input text remains ... */
604 /* Resize word list if needed. Just double the size. */
605 if (counted + 1 >= alloced) {
606 wanted = 2 * alloced;
607 new_words = g_realloc(words, sizeof(words[0]) * wanted);
613 state->words = words;
614 state->alloced = alloced;
617 /* Skip leading spaces. */
618 while (g_ascii_isspace(*p))
623 /* Add found word to word list. */
624 words[counted++] = p;
626 /* Find end of the word. Terminate loop upon EOS. */
627 while (*p && !g_ascii_isspace(*p))
632 /* More text follows. Terminate the word. */
637 * NULL terminate the word list. Provide its length so that
638 * calling code need not re-iterate the list to get the count.
640 words[counted] = NULL;
643 state->in_use = TRUE;
648 static void free_text_split(struct context *inc, char **words)
650 struct split_state *state;
654 if (words && words != state->words) {
655 sr_dbg("coding error, free() arg differs from split() result.");
658 /* "Double free" finally releases the memory. */
659 if (!state->in_use) {
660 g_free(state->words);
665 /* Mark as no longer in use. */
666 state->in_use = FALSE;
669 static gboolean have_header(GString *buf)
671 static const char *enddef_txt = "$enddefinitions";
672 static const char *end_txt = "$end";
676 /* Search for "end of definitions" section keyword. */
677 p = g_strstr_len(buf->str, buf->len, enddef_txt);
680 p += strlen(enddef_txt);
682 /* Search for end of section (content expected to be empty). */
683 p_stop = &buf->str[buf->len];
684 p_stop -= strlen(end_txt);
685 while (p < p_stop && g_ascii_isspace(*p))
687 if (strncmp(p, end_txt, strlen(end_txt)) != 0)
689 p += strlen(end_txt);
694 static int parse_timescale(struct context *inc, char *contents)
699 * The standard allows for values 1, 10 or 100
700 * and units s, ms, us, ns, ps and fs.
702 if (sr_parse_period(contents, &p, &q) != SR_OK) {
703 sr_err("Parsing $timescale failed.");
707 inc->samplerate = q / p;
708 sr_dbg("Samplerate: %" PRIu64, inc->samplerate);
710 /* Does not happen unless time value is non-standard */
711 sr_warn("Inexact rounding of samplerate, %" PRIu64 " / %" PRIu64 " to %" PRIu64 " Hz.",
712 q, p, inc->samplerate);
719 * Handle '$scope' and '$upscope' sections in the input file. Assume that
720 * input signals have a "base name", which may be ambiguous within the
721 * file. These names get declared within potentially nested scopes, which
722 * this implementation uses to create longer but hopefully unique and
723 * thus more usable sigrok channel names.
725 * Track the currently effective scopes in a string variable to simplify
726 * the channel name creation. Start from an empty string, then append the
727 * scope name and a separator when a new scope opens, and remove the last
728 * scope name when a scope closes. This allows to simply prefix basenames
729 * with the current scope to get a full name.
731 * It's an implementation detail to keep the trailing NUL here in the
732 * GString member, to simplify the g_strconcat() call in the channel name
736 * - Check whether scope types must get supported, this implementation
737 * does not distinguish between 'module' and 'begin' and what else
738 * may be seen. The first word simply gets ignored.
739 * - Check the allowed alphabet for scope names. This implementation
740 * assumes "programming language identifier" style (alphanumeric with
741 * underscores, plus brackets since we've seen them in example files).
743 static int parse_scope(struct context *inc, char *contents, gboolean is_up)
745 char *sep_pos, *name_pos;
750 * The 'upscope' case, drop one scope level (if available). Accept
751 * excess 'upscope' calls, assume that a previous 'scope' section
752 * was ignored because it referenced our software package's name.
756 * Check for a second right-most separator (and position
757 * right behind that, which is the start of the last
758 * scope component), or fallback to the start of string.
759 * g_string_erase() from that positon to the end to drop
760 * the last component.
762 name_pos = inc->scope_prefix->str;
764 sep_pos = strrchr(name_pos, SCOPE_SEP);
768 sep_pos = strrchr(name_pos, SCOPE_SEP);
771 name_pos = ++sep_pos;
773 length = name_pos - inc->scope_prefix->str;
774 g_string_truncate(inc->scope_prefix, length);
775 g_string_append_c(inc->scope_prefix, '\0');
776 sr_dbg("$upscope, prefix now: \"%s\"", inc->scope_prefix->str);
781 * The 'scope' case, add another scope level. But skip our own
782 * package name, assuming that this is an artificial node which
783 * was emitted by libsigrok's VCD output module.
785 sr_spew("$scope, got: \"%s\"", contents);
786 parts = g_strsplit_set(contents, " \r\n\t", 0);
787 remove_empty_parts(parts);
788 length = g_strv_length(parts);
790 sr_err("Unsupported 'scope' syntax: %s", contents);
795 if (strcmp(name_pos, PACKAGE_NAME) == 0) {
796 sr_info("Skipping scope with application's package name: %s",
801 /* Drop NUL, append scope name and separator, and re-add NUL. */
802 g_string_truncate(inc->scope_prefix, inc->scope_prefix->len - 1);
803 g_string_append_printf(inc->scope_prefix,
804 "%s%c%c", name_pos, SCOPE_SEP, '\0');
807 sr_dbg("$scope, prefix now: \"%s\"", inc->scope_prefix->str);
813 * Parse a $var section which describes a VCD signal ("variable").
815 * @param[in] inc Input module context.
816 * @param[in] contents Input text, content of $var section.
818 static int parse_header_var(struct context *inc, char *contents)
822 char *type, *size_txt, *id, *ref, *idx;
823 gboolean is_reg, is_wire, is_real, is_int;
824 enum sr_channeltype ch_type;
825 size_t size, next_size;
826 struct vcd_channel *vcd_ch;
829 * Format of $var or $reg header specs:
830 * $var type size identifier reference [opt-index] $end
832 parts = g_strsplit_set(contents, " \r\n\t", 0);
833 remove_empty_parts(parts);
834 length = g_strv_length(parts);
835 if (length != 4 && length != 5) {
836 sr_warn("$var section should have 4 or 5 items");
848 is_reg = g_strcmp0(type, "reg") == 0;
849 is_wire = g_strcmp0(type, "wire") == 0;
850 is_real = g_strcmp0(type, "real") == 0;
851 is_int = g_strcmp0(type, "integer") == 0;
853 if (is_reg || is_wire) {
854 ch_type = SR_CHANNEL_LOGIC;
855 } else if (is_real || is_int) {
856 ch_type = SR_CHANNEL_ANALOG;
858 sr_info("Unsupported signal type: '%s'", type);
863 size = strtol(size_txt, NULL, 10);
864 if (ch_type == SR_CHANNEL_ANALOG) {
865 if (is_real && size != 32 && size != 64) {
867 * The VCD input module does not depend on the
868 * specific width of the floating point value.
869 * This is just for information. Upon value
870 * changes, a mere string gets converted to
871 * float, so we may not care at all.
873 * Strictly speaking we might warn for 64bit
874 * (double precision) declarations, because
875 * sigrok internally uses single precision
878 sr_info("Unexpected real width: '%s'", size_txt);
880 /* Simplify code paths below, by assuming size 1. */
884 sr_warn("Unsupported signal size: '%s'", size_txt);
888 if (inc->conv_bits.max_bits < size)
889 inc->conv_bits.max_bits = size;
890 next_size = inc->logic_count + inc->analog_count + size;
891 if (inc->options.maxchannels && next_size > inc->options.maxchannels) {
892 sr_warn("Skipping '%s%s', exceeds requested channel count %zu.",
893 ref, idx ? idx : "", inc->options.maxchannels);
894 inc->ignored_signals = g_slist_append(inc->ignored_signals,
900 vcd_ch = g_malloc0(sizeof(*vcd_ch));
901 vcd_ch->identifier = g_strdup(id);
902 vcd_ch->name = g_strconcat(inc->scope_prefix->str, ref, idx, NULL);
904 vcd_ch->type = ch_type;
906 case SR_CHANNEL_LOGIC:
907 vcd_ch->array_index = inc->logic_count;
908 vcd_ch->byte_idx = vcd_ch->array_index / 8;
909 vcd_ch->bit_mask = 1 << (vcd_ch->array_index % 8);
910 inc->logic_count += size;
912 case SR_CHANNEL_ANALOG:
913 vcd_ch->array_index = inc->analog_count++;
914 /* TODO: Use proper 'digits' value for this input module. */
915 vcd_ch->submit_digits = is_real ? 2 : 0;
919 sr_spew("VCD signal %zu '%s' ID '%s' (size %zu), sr type %s, idx %zu.",
920 inc->vcdsignals, vcd_ch->name,
921 vcd_ch->identifier, vcd_ch->size,
922 vcd_ch->type == SR_CHANNEL_ANALOG ? "A" : "L",
923 vcd_ch->array_index);
924 inc->channels = g_slist_append(inc->channels, vcd_ch);
931 * Construct the name of the nth sigrok channel for a VCD signal.
933 * Uses the VCD signal name for scalar types and single-bit signals.
934 * Uses "signal.idx" for multi-bit VCD signals without a range spec in
935 * their declaration. Uses "signal[idx]" when a range is known and was
938 * @param[in] vcd_ch The VCD signal's description.
939 * @param[in] idx The sigrok channel's index within the VCD signal's group.
941 * @return An allocated text buffer which callers need to release, #NULL
942 * upon failure to create a sigrok channel name.
944 static char *get_channel_name(struct vcd_channel *vcd_ch, size_t idx)
946 char *open_pos, *close_pos, *check_pos, *endptr;
947 gboolean has_brackets, has_range;
948 size_t upper, lower, tmp;
951 /* Handle simple scalar types, and single-bit logic first. */
952 if (vcd_ch->size <= 1)
953 return g_strdup(vcd_ch->name);
956 * If not done before: Search for a matching pair of brackets in
957 * the right-most position at the very end of the string. Get the
958 * two colon separated numbers between the brackets, which are
959 * the range limits for array indices into the multi-bit signal.
960 * Grab the "base name" of the VCD signal.
962 * Notice that arrays can get nested. Earlier path components can
963 * be indexed as well, that's why we need the right-most range.
964 * This implementation does not handle bit vectors of size 1 here
965 * by explicit logic. The check for a [0:0] range would even fail.
966 * But the case of size 1 is handled above, and "happens to" give
967 * the expected result (just the VCD signal name).
969 * This implementation also deals with range limits in the reverse
970 * order, as well as ranges which are not 0-based (like "[4:7]").
972 if (!vcd_ch->base_name) {
974 open_pos = strrchr(vcd_ch->name, '[');
975 close_pos = strrchr(vcd_ch->name, ']');
976 if (close_pos && close_pos[1])
978 has_brackets = open_pos && close_pos && close_pos > open_pos;
982 check_pos = &open_pos[1];
984 upper = strtoul(check_pos, &endptr, 10);
985 if (!endptr || *endptr != ':')
989 check_pos = &endptr[1];
991 lower = strtoul(check_pos, &endptr, 10);
992 if (!endptr || endptr != close_pos)
995 if (has_range && lower > upper) {
1003 if (upper + 1 - lower != vcd_ch->size)
1007 /* Temporarily patch the VCD channel's name. */
1009 vcd_ch->base_name = g_strdup(vcd_ch->name);
1011 vcd_ch->range_lower = lower;
1012 vcd_ch->range_upper = upper;
1015 has_range = vcd_ch->range_lower + vcd_ch->range_upper;
1016 if (has_range && idx >= vcd_ch->size)
1019 return g_strdup_printf("%s.%zu", vcd_ch->name, idx);
1022 * Create a sigrok channel name with just the bit's index in
1023 * brackets. This avoids "name[7:0].3" results, instead results
1026 ch_name = g_strdup_printf("%s[%zu]",
1027 vcd_ch->base_name, vcd_ch->range_lower + idx);
1032 * Create (analog or logic) sigrok channels for the VCD signals. Create
1033 * multiple sigrok channels for vector input since sigrok has no concept
1034 * of multi-bit signals. Create a channel group for the vector's bits
1035 * though to reflect that they form a unit. This is beneficial when UIs
1036 * support optional "collapsed" displays of channel groups (like
1037 * "parallel bus, hex output").
1039 * Defer channel creation until after completion of parsing the input
1040 * file header. Make sure to create all logic channels first before the
1041 * analog channels get created. This avoids issues with the mapping of
1042 * channel indices to bitmap positions in the sample buffer.
1044 static void create_channels(const struct sr_input *in,
1045 struct sr_dev_inst *sdi, enum sr_channeltype ch_type)
1047 struct context *inc;
1050 struct vcd_channel *vcd_ch;
1053 struct sr_channel_group *cg;
1054 struct sr_channel *ch;
1059 if (ch_type > SR_CHANNEL_LOGIC)
1060 ch_idx += inc->logic_count;
1061 if (ch_type > SR_CHANNEL_ANALOG)
1062 ch_idx += inc->analog_count;
1063 for (l = inc->channels; l; l = l->next) {
1065 if (vcd_ch->type != ch_type)
1068 if (vcd_ch->size != 1) {
1069 cg = g_malloc0(sizeof(*cg));
1070 cg->name = g_strdup(vcd_ch->name);
1072 for (size_idx = 0; size_idx < vcd_ch->size; size_idx++) {
1073 ch_name = get_channel_name(vcd_ch, size_idx);
1074 sr_dbg("sigrok channel idx %zu, name %s, type %s, en %d.",
1076 ch_type == SR_CHANNEL_ANALOG ? "A" : "L", TRUE);
1077 ch = sr_channel_new(sdi, ch_idx, ch_type, TRUE, ch_name);
1081 cg->channels = g_slist_append(cg->channels, ch);
1084 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
1088 static void create_feeds(const struct sr_input *in)
1090 struct context *inc;
1092 struct vcd_channel *vcd_ch;
1094 struct sr_channel *ch;
1098 /* Create one feed for logic data. */
1099 if (inc->logic_count) {
1100 inc->unit_size = (inc->logic_count + 7) / 8;
1101 inc->feed_logic = feed_queue_logic_alloc(in->sdi,
1102 CHUNK_SIZE / inc->unit_size, inc->unit_size);
1105 /* Create one feed per analog channel. */
1106 for (l = inc->channels; l; l = l->next) {
1108 if (vcd_ch->type != SR_CHANNEL_ANALOG)
1110 ch_idx = vcd_ch->array_index;
1111 ch_idx += inc->logic_count;
1112 ch = g_slist_nth_data(in->sdi->channels, ch_idx);
1113 vcd_ch->feed_analog = feed_queue_analog_alloc(in->sdi,
1114 CHUNK_SIZE / sizeof(float),
1115 vcd_ch->submit_digits, ch);
1120 * Keep track of a previously created channel list, in preparation of
1121 * re-reading the input file. Gets called from reset()/cleanup() paths.
1123 static void keep_header_for_reread(const struct sr_input *in)
1125 struct context *inc;
1129 g_slist_free_full(inc->prev.sr_groups, cg_free);
1130 inc->prev.sr_groups = in->sdi->channel_groups;
1131 in->sdi->channel_groups = NULL;
1133 g_slist_free_full(inc->prev.sr_channels, sr_channel_free_cb);
1134 inc->prev.sr_channels = in->sdi->channels;
1135 in->sdi->channels = NULL;
1139 * Check whether the input file is being re-read, and refuse operation
1140 * when essential parameters of the acquisition have changed in ways
1141 * that are unexpected to calling applications. Gets called after the
1142 * file header got parsed (again).
1144 * Changing the channel list across re-imports of the same file is not
1145 * supported, by design and for valid reasons, see bug #1215 for details.
1146 * Users are expected to start new sessions when they change these
1147 * essential parameters in the acquisition's setup. When we accept the
1148 * re-read file, then make sure to keep using the previous channel list,
1149 * applications may still reference them.
1151 static gboolean check_header_in_reread(const struct sr_input *in)
1153 struct context *inc;
1160 if (!inc->prev.sr_channels)
1163 if (sr_channel_lists_differ(inc->prev.sr_channels, in->sdi->channels)) {
1164 sr_err("Channel list change not supported for file re-read.");
1168 g_slist_free_full(in->sdi->channel_groups, cg_free);
1169 in->sdi->channel_groups = inc->prev.sr_groups;
1170 inc->prev.sr_groups = NULL;
1172 g_slist_free_full(in->sdi->channels, sr_channel_free_cb);
1173 in->sdi->channels = inc->prev.sr_channels;
1174 inc->prev.sr_channels = NULL;
1179 /* Parse VCD file header sections (rate and variables declarations). */
1180 static int parse_header(const struct sr_input *in, GString *buf)
1182 struct context *inc;
1184 char *name, *contents;
1190 /* Parse sections until complete header was seen. */
1192 name = contents = NULL;
1193 inc->conv_bits.max_bits = 1;
1194 while (parse_section(buf, &name, &contents)) {
1195 sr_dbg("Section '%s', contents '%s'.", name, contents);
1197 if (g_strcmp0(name, "enddefinitions") == 0) {
1201 if (g_strcmp0(name, "timescale") == 0) {
1202 if (parse_timescale(inc, contents) != SR_OK)
1206 if (g_strcmp0(name, "scope") == 0) {
1207 if (parse_scope(inc, contents, FALSE) != SR_OK)
1211 if (g_strcmp0(name, "upscope") == 0) {
1212 if (parse_scope(inc, NULL, TRUE) != SR_OK)
1216 if (g_strcmp0(name, "var") == 0) {
1217 if (parse_header_var(inc, contents) != SR_OK)
1234 inc->got_header = status;
1238 /* Create sigrok channels here, late, logic before analog. */
1239 create_channels(in, in->sdi, SR_CHANNEL_LOGIC);
1240 create_channels(in, in->sdi, SR_CHANNEL_ANALOG);
1241 if (!check_header_in_reread(in))
1246 * Allocate space for text to number conversion, and buffers to
1247 * hold current sample values before submission to the session
1248 * feed. Allocate one buffer for all logic bits, and another for
1249 * all floating point values of all analog channels.
1251 * The buffers get updated when the VCD input stream communicates
1252 * value changes. Upon reception of VCD timestamps, the buffer can
1253 * provide the previously received values, to "fill in the gaps"
1254 * in the generation of a continuous stream of samples for the
1257 size = (inc->conv_bits.max_bits + 7) / 8;
1258 inc->conv_bits.unit_size = size;
1259 inc->conv_bits.value = g_malloc0(size);
1260 if (!inc->conv_bits.value)
1261 return SR_ERR_MALLOC;
1263 size = (inc->logic_count + 7) / 8;
1264 inc->unit_size = size;
1265 inc->current_logic = g_malloc0(size);
1266 if (inc->unit_size && !inc->current_logic)
1267 return SR_ERR_MALLOC;
1268 size = sizeof(inc->current_floats[0]) * inc->analog_count;
1269 inc->current_floats = g_malloc0(size);
1270 if (size && !inc->current_floats)
1271 return SR_ERR_MALLOC;
1272 for (size = 0; size < inc->analog_count; size++)
1273 inc->current_floats[size] = 0.;
1275 ret = ts_stats_prep(inc);
1283 * Add N copies of previously received values to the session, before
1284 * subsequent value changes will update the data buffer. Locally buffer
1285 * sample data to minimize the number of send() calls.
1287 static void add_samples(const struct sr_input *in, size_t count, gboolean flush)
1289 struct context *inc;
1291 struct vcd_channel *vcd_ch;
1292 struct feed_queue_analog *q;
1297 if (inc->logic_count) {
1298 feed_queue_logic_submit(inc->feed_logic,
1299 inc->current_logic, count);
1301 feed_queue_logic_flush(inc->feed_logic);
1303 for (ch_list = inc->channels; ch_list; ch_list = ch_list->next) {
1304 vcd_ch = ch_list->data;
1305 if (vcd_ch->type != SR_CHANNEL_ANALOG)
1307 q = vcd_ch->feed_analog;
1310 value = inc->current_floats[vcd_ch->array_index];
1311 feed_queue_analog_submit(q, value, count);
1313 feed_queue_analog_flush(q);
1317 static gint vcd_compare_id(gconstpointer a, gconstpointer b)
1319 return strcmp((const char *)a, (const char *)b);
1322 static gboolean is_ignored(struct context *inc, const char *id)
1326 ignored = g_slist_find_custom(inc->ignored_signals, id, vcd_compare_id);
1327 return ignored != NULL;
1331 * Get an analog channel's value from a bit pattern (VCD 'integer' type).
1332 * The implementation assumes a maximum integer width (64bit), the API
1333 * doesn't (beyond the return data type). The use of SR_CHANNEL_ANALOG
1334 * channels may further constraint the number of significant digits
1335 * (current asumption: float -> 23bit).
1337 static float get_int_val(uint8_t *in_bits_data, size_t in_bits_count)
1340 size_t byte_count, byte_idx;
1341 float flt_value; /* typeof(inc->current_floats[0]) */
1343 /* Convert bit pattern to integer number (limited range). */
1345 byte_count = (in_bits_count + 7) / 8;
1346 for (byte_idx = 0; byte_idx < byte_count; byte_idx++) {
1347 if (byte_idx >= sizeof(int_value))
1349 int_value |= *in_bits_data++ << (byte_idx * 8);
1351 flt_value = int_value;
1357 * Set a logic channel's level depending on the VCD signal's identifier
1358 * and parsed value. Multi-bit VCD values will affect several sigrok
1359 * channels. One VCD signal name can translate to several sigrok channels.
1361 static void process_bits(struct context *inc, char *identifier,
1362 uint8_t *in_bits_data, size_t in_bits_count)
1367 struct vcd_channel *vcd_ch;
1370 uint8_t *in_bit_ptr, in_bit_mask;
1371 uint8_t *out_bit_ptr, out_bit_mask;
1377 for (l = inc->channels; l; l = l->next) {
1379 if (g_strcmp0(identifier, vcd_ch->identifier) != 0)
1381 if (vcd_ch->type == SR_CHANNEL_ANALOG) {
1382 /* Special case for 'integer' VCD signal types. */
1383 size = vcd_ch->size; /* Flag for "VCD signal found". */
1385 int_val = get_int_val(in_bits_data, in_bits_count);
1388 inc->current_floats[vcd_ch->array_index] = int_val;
1391 if (vcd_ch->type != SR_CHANNEL_LOGIC)
1393 sr_spew("Processing %s data, id '%s', ch %zu sz %zu",
1394 (size == 1) ? "bit" : "vector",
1395 identifier, vcd_ch->array_index, vcd_ch->size);
1397 /* Found our (logic) channel. Setup in/out bit positions. */
1398 size = vcd_ch->size;
1399 in_bit_ptr = in_bits_data;
1400 in_bit_mask = 1 << 0;
1401 out_bit_ptr = &inc->current_logic[vcd_ch->byte_idx];
1402 out_bit_mask = vcd_ch->bit_mask;
1405 * Pass VCD input bit(s) to sigrok logic bits. Conversion
1406 * must be done repeatedly because one VCD signal name
1407 * can translate to several sigrok channels, and shifting
1408 * a previously computed bit field to another channel's
1409 * position in the buffer would be nearly as expensive,
1410 * and certain would increase complexity of the code.
1412 for (bit_idx = 0; bit_idx < size; bit_idx++) {
1413 /* Get the bit value from input data. */
1415 if (bit_idx < in_bits_count) {
1416 bit_val = *in_bit_ptr & in_bit_mask;
1419 in_bit_mask = 1 << 0;
1423 /* Manipulate the sample buffer data image. */
1425 *out_bit_ptr |= out_bit_mask;
1427 *out_bit_ptr &= ~out_bit_mask;
1428 /* Update output position after bitmap update. */
1430 if (!out_bit_mask) {
1431 out_bit_mask = 1 << 0;
1436 if (!size && !is_ignored(inc, identifier))
1437 sr_warn("VCD signal not found for ID '%s'.", identifier);
1441 * Set an analog channel's value from a floating point number. One
1442 * VCD signal name can translate to several sigrok channels.
1444 static void process_real(struct context *inc, char *identifier, float real_val)
1448 struct vcd_channel *vcd_ch;
1451 for (l = inc->channels; l; l = l->next) {
1453 if (vcd_ch->type != SR_CHANNEL_ANALOG)
1455 if (g_strcmp0(identifier, vcd_ch->identifier) != 0)
1458 /* Found our (analog) channel. */
1460 sr_spew("Processing real data, id '%s', ch %zu, val %.16g",
1461 identifier, vcd_ch->array_index, real_val);
1462 inc->current_floats[vcd_ch->array_index] = real_val;
1464 if (!found && !is_ignored(inc, identifier))
1465 sr_warn("VCD signal not found for ID '%s'.", identifier);
1469 * Converts a bit position's text character to a number value.
1471 * TODO Check for complete coverage of Verilog's standard logic values
1472 * (IEEE-1364). The set is said to be “01XZHUWL-”, which only a part of
1473 * is handled here. What would be the complete mapping?
1474 * - 0/L -> bit value 0
1475 * - 1/H -> bit value 1
1476 * - X "don't care" -> TODO
1477 * - Z "high impedance" -> TODO
1478 * - W "weak(?)" -> TODO
1479 * - U "undefined" -> TODO
1480 * - '-' "TODO" -> TODO
1482 * For simplicity, this input module implementation maps "known low"
1483 * values to 0, and "known high" values to 1. All other values will
1484 * end up assuming "low" (return number 0), while callers might warn.
1485 * It's up to users to provide compatible input data, or accept the
1486 * warnings. Silently accepting unknown input data is not desirable.
1488 static uint8_t vcd_char_to_value(char bit_char, int *warn)
1491 bit_char = g_ascii_tolower(bit_char);
1493 /* Convert the "undisputed" variants. */
1494 if (bit_char == '0' || bit_char == 'l')
1496 if (bit_char == '1' || bit_char == 'h')
1499 /* Convert the "uncertain" variants. */
1502 if (bit_char == 'x' || bit_char == 'z')
1504 if (bit_char == 'u')
1506 if (bit_char == '-')
1509 /* Unhandled input text. */
1513 /* Parse one text line of the data section. */
1514 static int parse_textline(const struct sr_input *in, char *lines)
1516 struct context *inc;
1519 size_t word_count, word_idx;
1520 char *curr_word, *next_word, curr_first;
1521 gboolean is_timestamp, is_section, is_real, is_multibit, is_singlebit;
1523 char *identifier, *endptr;
1529 * Split the caller's text lines into a list of space separated
1530 * words. Note that some of the branches consume the very next
1531 * words as well, and assume that both adjacent words will be
1532 * available when the first word is seen. This constraint applies
1533 * to bit vector data, multi-bit integers and real (float) data,
1534 * as well as single-bit data with whitespace before its
1535 * identifier (if that's valid in VCD, we'd accept it here).
1536 * The fact that callers always pass complete text lines should
1537 * make this assumption acceptable.
1540 words = split_text_line(inc, lines, &word_count);
1541 for (word_idx = 0; word_idx < word_count; word_idx++) {
1543 * Make the next two words available, to simpilify code
1544 * paths below. The second word is optional here.
1546 curr_word = words[word_idx];
1547 if (!curr_word && !curr_word[0])
1549 curr_first = g_ascii_tolower(curr_word[0]);
1550 next_word = words[word_idx + 1];
1551 if (next_word && !next_word[0])
1555 * Optionally skip some sections that can be interleaved
1556 * with data (and may or may not be supported by this
1557 * input module). If the section is not skipped but the
1558 * $end keyword needs to get tracked, specifically handle
1559 * this case, for improved robustness (still reject files
1560 * which happen to use invalid syntax).
1562 if (inc->skip_until_end) {
1563 if (strcmp(curr_word, "$end") == 0) {
1564 /* Done with unhandled/unknown section. */
1565 sr_dbg("done skipping until $end");
1566 inc->skip_until_end = FALSE;
1568 sr_spew("skipping word: %s", curr_word);
1572 if (inc->ignore_end_keyword) {
1573 if (strcmp(curr_word, "$end") == 0) {
1574 sr_dbg("done ignoring $end keyword");
1575 inc->ignore_end_keyword = FALSE;
1581 * There may be $keyword sections inside the data part of
1582 * the input file. Do inspect some of the sections' content
1583 * but ignore their surrounding keywords. Silently skip
1584 * unsupported section types (which transparently covers
1585 * $comment sections).
1587 is_section = curr_first == '$' && curr_word[1];
1589 gboolean inspect_data;
1591 inspect_data = FALSE;
1592 inspect_data |= g_strcmp0(curr_word, "$dumpvars") == 0;
1593 inspect_data |= g_strcmp0(curr_word, "$dumpon") == 0;
1594 inspect_data |= g_strcmp0(curr_word, "$dumpoff") == 0;
1596 /* Ignore keywords, yet parse contents. */
1597 sr_dbg("%s section, will parse content", curr_word);
1598 inc->ignore_end_keyword = TRUE;
1600 /* Ignore section from here up to $end. */
1601 sr_dbg("%s section, will skip until $end", curr_word);
1602 inc->skip_until_end = TRUE;
1608 * Numbers prefixed by '#' are timestamps, which translate
1609 * to sigrok sample numbers. Apply optional downsampling,
1610 * and apply the 'skip' logic. Check the recent timestamp
1611 * for plausibility. Submit the corresponding number of
1612 * samples of previously accumulated data values to the
1615 is_timestamp = curr_first == '#' && g_ascii_isdigit(curr_word[1]);
1618 timestamp = strtoull(&curr_word[1], &endptr, 10);
1619 if (!endptr || *endptr) {
1620 sr_err("Invalid timestamp: %s.", curr_word);
1624 sr_spew("Got timestamp: %" PRIu64, timestamp);
1625 ret = ts_stats_check(&inc->ts_stats, timestamp);
1628 if (inc->options.downsample > 1) {
1629 timestamp /= inc->options.downsample;
1630 sr_spew("Downsampled timestamp: %" PRIu64, timestamp);
1634 * Skip < 0 => skip until first timestamp.
1635 * Skip = 0 => don't skip
1636 * Skip > 0 => skip until timestamp >= skip.
1638 if (inc->options.skip_specified && !inc->use_skip) {
1639 sr_dbg("Seeding skip from user spec %" PRIu64,
1640 inc->options.skip_starttime);
1641 inc->prev_timestamp = inc->options.skip_starttime;
1642 inc->use_skip = TRUE;
1644 if (!inc->use_skip) {
1645 sr_dbg("Seeding skip from first timestamp");
1646 inc->options.skip_starttime = timestamp;
1647 inc->prev_timestamp = timestamp;
1648 inc->use_skip = TRUE;
1651 if (inc->options.skip_starttime && timestamp < inc->options.skip_starttime) {
1652 sr_spew("Timestamp skipped, before user spec");
1653 inc->prev_timestamp = inc->options.skip_starttime;
1656 if (timestamp == inc->prev_timestamp) {
1658 * Ignore repeated timestamps (e.g. sigrok
1659 * outputs these). Can also happen when
1660 * downsampling makes distinct input values
1661 * end up at the same scaled down value.
1662 * Also transparently covers the initial
1665 sr_spew("Timestamp is identical to previous timestamp");
1668 if (timestamp < inc->prev_timestamp) {
1669 sr_err("Invalid timestamp: %" PRIu64 " (leap backwards).", timestamp);
1673 if (inc->options.compress) {
1674 /* Compress long idle periods */
1675 count = timestamp - inc->prev_timestamp;
1676 if (count > inc->options.compress) {
1677 sr_dbg("Long idle period, compressing");
1678 count = timestamp - inc->options.compress;
1679 inc->prev_timestamp = count;
1683 /* Generate samples from prev_timestamp up to timestamp - 1. */
1684 count = timestamp - inc->prev_timestamp;
1685 sr_spew("Got a new timestamp, feeding %zu samples", count);
1686 add_samples(in, count, FALSE);
1687 inc->prev_timestamp = timestamp;
1688 inc->data_after_timestamp = FALSE;
1691 inc->data_after_timestamp = TRUE;
1694 * Data values come in different formats, are associated
1695 * with channel identifiers, and correspond to the period
1696 * of time from the most recent timestamp to the next
1699 * Supported input data formats are:
1700 * - R<value> <sep> <id> (analog channel, VCD type 'real').
1701 * - B<value> <sep> <id> (analog channel, VCD type 'integer').
1702 * - B<value> <sep> <id> (logic channels, VCD bit vectors).
1703 * - <value> <id> (logic channel, VCD single-bit values).
1705 * Input values can be:
1706 * - Floating point numbers.
1707 * - Bit strings (which covers multi-bit aka integers
1708 * as well as vectors).
1712 * - Individual bits can be 0/1 which is supported by
1713 * libsigrok, or x or z which is treated like 0 here
1714 * (sigrok lacks support for ternary logic, neither is
1715 * there support for the full IEEE set of values).
1716 * - Single-bit values typically won't be separated from
1717 * the signal identifer, multi-bit values and floats
1718 * are separated (will reference the next word). This
1719 * implementation silently accepts separators for
1720 * single-bit values, too.
1722 is_real = curr_first == 'r' && curr_word[1];
1723 is_multibit = curr_first == 'b' && curr_word[1];
1724 is_singlebit = curr_first == '0' || curr_first == '1';
1725 is_singlebit |= curr_first == 'l' || curr_first == 'h';
1726 is_singlebit |= curr_first == 'x' || curr_first == 'z';
1727 is_singlebit |= curr_first == 'u' || curr_first == '-';
1732 real_text = &curr_word[1];
1733 identifier = next_word;
1735 if (!*real_text || !identifier || !*identifier) {
1736 sr_err("Unexpected real format.");
1740 sr_spew("Got real data %s for id '%s'.",
1741 real_text, identifier);
1742 if (sr_atof_ascii(real_text, &real_val) != SR_OK) {
1743 sr_err("Cannot convert value: %s.", real_text);
1747 process_real(inc, identifier, real_val);
1751 char *bits_text_start;
1753 char *bits_text, bit_char;
1755 uint8_t *value_ptr, value_mask;
1756 GString *bits_val_text;
1759 * Fold in single-bit code path here? To re-use
1760 * the X/Z support. Current redundancy is few so
1761 * there is little pressure to unify code paths.
1762 * Also multi-bit handling is often different
1763 * from single-bit handling, so the "unified"
1764 * path would often check for special cases. So
1765 * we may never unify code paths at all here.
1767 bits_text = &curr_word[1];
1768 identifier = next_word;
1771 if (!*bits_text || !identifier || !*identifier) {
1772 sr_err("Unexpected integer/vector format.");
1776 sr_spew("Got integer/vector data %s for id '%s'.",
1777 bits_text, identifier);
1780 * Accept a bit string of arbitrary length (sort
1781 * of, within the limits of the previously setup
1782 * conversion buffer). The input text omits the
1783 * leading zeroes, hence we convert from end to
1784 * the start, to get the significant bits. There
1785 * should only be errors for invalid input, or
1786 * for input that is rather strange (data holds
1787 * more bits than the signal's declaration in
1788 * the header suggested). Silently accept data
1789 * that fits in the conversion buffer, and has
1790 * more significant bits than the signal's type
1791 * (that'd be non-sence yet acceptable input).
1793 bits_text_start = bits_text;
1794 bits_text += strlen(bits_text);
1795 bit_count = bits_text - bits_text_start;
1796 if (bit_count > inc->conv_bits.max_bits) {
1797 sr_err("Value exceeds conversion buffer: %s",
1802 memset(inc->conv_bits.value, 0, inc->conv_bits.unit_size);
1803 value_ptr = &inc->conv_bits.value[0];
1804 value_mask = 1 << 0;
1805 inc->conv_bits.sig_count = 0;
1806 while (bits_text > bits_text_start) {
1807 inc->conv_bits.sig_count++;
1808 bit_char = *(--bits_text);
1809 bit_value = vcd_char_to_value(bit_char, NULL);
1810 if (bit_value == 0) {
1812 } else if (bit_value == 1) {
1813 *value_ptr |= value_mask;
1815 inc->conv_bits.sig_count = 0;
1821 value_mask = 1 << 0;
1824 if (!inc->conv_bits.sig_count) {
1825 sr_err("Unexpected vector format: %s",
1830 if (sr_log_loglevel_get() >= SR_LOG_SPEW) {
1831 bits_val_text = sr_hexdump_new(inc->conv_bits.value,
1832 value_ptr - inc->conv_bits.value + 1);
1833 sr_spew("Vector value: %s.", bits_val_text->str);
1834 sr_hexdump_free(bits_val_text);
1837 process_bits(inc, identifier,
1838 inc->conv_bits.value, inc->conv_bits.sig_count);
1842 char *bits_text, bit_char;
1845 /* Get the value text, and signal identifier. */
1846 bits_text = &curr_word[0];
1847 bit_char = *bits_text;
1849 sr_err("Bit value missing.");
1853 identifier = ++bits_text;
1855 identifier = next_word;
1858 if (!identifier || !*identifier) {
1859 sr_err("Identifier missing.");
1864 /* Convert value text to single-bit number. */
1865 bit_value = vcd_char_to_value(bit_char, NULL);
1866 if (bit_value != 0 && bit_value != 1) {
1867 sr_err("Unsupported bit value '%c'.", bit_char);
1871 inc->conv_bits.value[0] = bit_value;
1872 process_bits(inc, identifier, inc->conv_bits.value, 1);
1876 /* Design choice: Consider unsupported input fatal. */
1877 sr_err("Unknown token '%s'.", curr_word);
1881 free_text_split(inc, words);
1886 static int process_buffer(struct sr_input *in, gboolean is_eof)
1888 struct context *inc;
1889 uint64_t samplerate;
1892 char *rdptr, *endptr, *trimptr;
1897 /* Send feed header and samplerate (once) before sample data. */
1898 if (!inc->started) {
1899 std_session_send_df_header(in->sdi);
1901 samplerate = inc->samplerate / inc->options.downsample;
1903 gvar = g_variant_new_uint64(samplerate);
1904 sr_session_send_meta(in->sdi, SR_CONF_SAMPLERATE, gvar);
1907 inc->started = TRUE;
1911 * Workaround broken generators which output incomplete text
1912 * lines. Enforce the trailing line feed. Proper input is not
1913 * harmed by another empty line of input data.
1916 g_string_append_c(in->buf, '\n');
1918 /* Find and process complete text lines in the input data. */
1920 rdptr = in->buf->str;
1922 rdlen = &in->buf->str[in->buf->len] - rdptr;
1923 endptr = g_strstr_len(rdptr, rdlen, "\n");
1928 while (g_ascii_isspace(*rdptr))
1930 while (trimptr > rdptr && g_ascii_isspace(trimptr[-1]))
1931 *(--trimptr) = '\0';
1936 ret = parse_textline(in, rdptr);
1941 rdlen = rdptr - in->buf->str;
1942 g_string_erase(in->buf, 0, rdlen);
1947 static int format_match(GHashTable *metadata, unsigned int *confidence)
1949 GString *buf, *tmpbuf;
1951 char *name, *contents;
1953 buf = g_hash_table_lookup(metadata,
1954 GINT_TO_POINTER(SR_INPUT_META_HEADER));
1955 tmpbuf = g_string_new_len(buf->str, buf->len);
1958 * If we can parse the first section correctly, then it is
1959 * assumed that the input is in VCD format.
1961 check_remove_bom(tmpbuf);
1962 status = parse_section(tmpbuf, &name, &contents);
1963 g_string_free(tmpbuf, TRUE);
1974 static int init(struct sr_input *in, GHashTable *options)
1976 struct context *inc;
1979 inc = g_malloc0(sizeof(*inc));
1981 data = g_hash_table_lookup(options, "numchannels");
1982 inc->options.maxchannels = g_variant_get_uint32(data);
1984 data = g_hash_table_lookup(options, "downsample");
1985 inc->options.downsample = g_variant_get_uint64(data);
1986 if (inc->options.downsample < 1)
1987 inc->options.downsample = 1;
1989 data = g_hash_table_lookup(options, "compress");
1990 inc->options.compress = g_variant_get_uint64(data);
1991 inc->options.compress /= inc->options.downsample;
1993 data = g_hash_table_lookup(options, "skip");
1995 inc->options.skip_specified = TRUE;
1996 inc->options.skip_starttime = g_variant_get_uint64(data);
1997 if (inc->options.skip_starttime == ~UINT64_C(0)) {
1998 inc->options.skip_specified = FALSE;
1999 inc->options.skip_starttime = 0;
2001 inc->options.skip_starttime /= inc->options.downsample;
2004 in->sdi = g_malloc0(sizeof(*in->sdi));
2007 inc->scope_prefix = g_string_new("\0");
2012 static int receive(struct sr_input *in, GString *buf)
2014 struct context *inc;
2019 /* Collect all input chunks, potential deferred processing. */
2020 g_string_append_len(in->buf, buf->str, buf->len);
2021 if (!inc->got_header && in->buf->len == buf->len)
2022 check_remove_bom(in->buf);
2024 /* Must complete reception of the VCD header first. */
2025 if (!inc->got_header) {
2026 if (!have_header(in->buf))
2028 ret = parse_header(in, in->buf);
2031 /* sdi is ready, notify frontend. */
2032 in->sdi_ready = TRUE;
2036 /* Process sample data. */
2037 ret = process_buffer(in, FALSE);
2042 static int end(struct sr_input *in)
2044 struct context *inc;
2050 /* Must complete processing of previously received chunks. */
2052 ret = process_buffer(in, TRUE);
2056 /* Flush most recently queued sample data when EOF is seen. */
2057 count = inc->data_after_timestamp ? 1 : 0;
2058 add_samples(in, count, TRUE);
2060 /* Optionally suggest downsampling after all input data was seen. */
2061 (void)ts_stats_post(inc, !inc->data_after_timestamp);
2063 /* Must send DF_END when DF_HEADER was sent before. */
2065 std_session_send_df_end(in->sdi);
2070 static void cleanup(struct sr_input *in)
2072 struct context *inc;
2076 keep_header_for_reread(in);
2078 g_slist_free_full(inc->channels, free_channel);
2079 inc->channels = NULL;
2080 feed_queue_logic_free(inc->feed_logic);
2081 inc->feed_logic = NULL;
2082 g_free(inc->conv_bits.value);
2083 inc->conv_bits.value = NULL;
2084 g_free(inc->current_logic);
2085 inc->current_logic = NULL;
2086 g_free(inc->current_floats);
2087 inc->current_floats = NULL;
2088 g_string_free(inc->scope_prefix, TRUE);
2089 inc->scope_prefix = NULL;
2090 g_slist_free_full(inc->ignored_signals, g_free);
2091 inc->ignored_signals = NULL;
2092 free_text_split(inc, NULL);
2095 static int reset(struct sr_input *in)
2097 struct context *inc;
2098 struct vcd_user_opt save;
2099 struct vcd_prev prev;
2103 /* Relase previously allocated resources. */
2105 g_string_truncate(in->buf, 0);
2107 /* Restore part of the context, init() won't run again. */
2108 save = inc->options;
2110 memset(inc, 0, sizeof(*inc));
2111 inc->options = save;
2113 inc->scope_prefix = g_string_new("\0");
2126 static struct sr_option options[] = {
2128 "numchannels", "Max number of sigrok channels",
2129 "The maximum number of sigrok channels to create for VCD input signals.",
2132 [OPT_DOWN_SAMPLE] = {
2133 "downsample", "Downsampling factor",
2134 "Downsample the input file's samplerate, i.e. divide by the specified factor.",
2137 [OPT_SKIP_COUNT] = {
2138 "skip", "Skip this many initial samples",
2139 "Skip samples until the specified timestamp. "
2140 "By default samples start at the first timestamp in the file. "
2141 "Value 0 creates samples starting at timestamp 0. "
2142 "Values above 0 only start processing at the given timestamp.",
2146 "compress", "Compress idle periods",
2147 "Compress idle periods which are longer than the specified number of timescale ticks.",
2150 [OPT_MAX] = ALL_ZERO,
2153 static const struct sr_option *get_options(void)
2155 if (!options[0].def) {
2156 options[OPT_NUM_CHANS].def = g_variant_ref_sink(g_variant_new_uint32(0));
2157 options[OPT_DOWN_SAMPLE].def = g_variant_ref_sink(g_variant_new_uint64(1));
2158 options[OPT_SKIP_COUNT].def = g_variant_ref_sink(g_variant_new_uint64(~UINT64_C(0)));
2159 options[OPT_COMPRESS].def = g_variant_ref_sink(g_variant_new_uint64(0));
2165 SR_PRIV struct sr_input_module input_vcd = {
2168 .desc = "Value Change Dump data",
2169 .exts = (const char*[]){"vcd", NULL},
2170 .metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
2171 .options = get_options,
2172 .format_match = format_match,