X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Finput%2Fvcd.c;h=b9e9497dc8baf07b65370329179a615d2c175531;hb=ed367d68203593224af3c9593cfef0662b56007c;hp=54e9c73359854d222670ad838efb700a6cc74520;hpb=c01378c95f34e60d3b67f84dc3a6c3c6c154186d;p=libsigrok.git

diff --git a/src/input/vcd.c b/src/input/vcd.c
index 54e9c733..b9e9497d 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)
  *
@@ -67,12 +67,12 @@
 
 #define LOG_PREFIX "input/vcd"
 
-#define DEFAULT_NUM_CHANNELS 8
-#define CHUNKSIZE (1024 * 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;
@@ -94,7 +94,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)
 {
@@ -106,6 +106,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++;
@@ -206,27 +210,35 @@ 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);
@@ -253,7 +265,7 @@ static gboolean parse_header(const struct sr_input *in, GString *buf)
 	return status;
 }
 
-static int format_match(GHashTable *metadata)
+static int format_match(GHashTable *metadata, unsigned int *confidence)
 {
 	GString *buf, *tmpbuf;
 	gboolean status;
@@ -271,7 +283,11 @@ 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 all accumulated bytes from inc->buffer. */
@@ -307,7 +323,7 @@ static void add_samples(const struct sr_input *in, size_t count)
 	uint8_t *p;
 
 	inc = in->priv;
-	samples_per_chunk = CHUNKSIZE / inc->bytes_per_sample;
+	samples_per_chunk = CHUNK_SIZE / inc->bytes_per_sample;
 
 	while (count) {
 		space_left = samples_per_chunk - inc->samples_in_buffer;
@@ -328,18 +344,39 @@ static void add_samples(const struct sr_input *in, size_t count)
 	}
 }
 
+/* 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;
-	unsigned int bit, i, j;
+	uint64_t timestamp;
+	unsigned int bit, i;
 	char **tokens;
 
 	inc = in->priv;
-	prev_timestamp = 0;
 
 	/* Read one space-delimited token at a time. */
 	tokens = g_strsplit_set(data, " \t\r\n", 0);
@@ -366,22 +403,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. */
-				add_samples(in, 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') {
 			/*
@@ -398,10 +439,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');
 
@@ -410,30 +472,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 */
-					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);
+				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]);
 		}
@@ -443,18 +490,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;
-	}
 	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;
@@ -466,12 +506,7 @@ static int init(struct sr_input *in, GHashTable *options)
 	in->sdi = g_malloc0(sizeof(struct sr_dev_inst));
 	in->priv = inc;
 
-	inc->buffer = g_malloc(CHUNKSIZE);
-
-	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;
 }
@@ -503,7 +538,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;
@@ -555,7 +590,6 @@ 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;
 
@@ -569,10 +603,8 @@ static int end(struct sr_input *in)
 	/* Send any samples that haven't been sent yet. */
 	send_buffer(in);
 
-	if (inc->started) {
-		packet.type = SR_DF_END;
-		sr_session_send(in->sdi, &packet);
-	}
+	if (inc->started)
+		std_session_send_df_end(in->sdi);
 
 	return ret;
 }
@@ -589,18 +621,30 @@ static void cleanup(struct sr_input *in)
 	inc->current_levels = NULL;
 }
 
+static int reset(struct sr_input *in)
+{
+	struct context *inc = in->priv;
+
+	cleanup(in);
+	inc->started = FALSE;
+	g_string_truncate(in->buf, 0);
+
+	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 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));
@@ -612,7 +656,7 @@ static const 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,
@@ -621,4 +665,5 @@ SR_PRIV struct sr_input_module input_vcd = {
 	.receive = receive,
 	.end = end,
 	.cleanup = cleanup,
+	.reset = reset,
 };