* - more than 64 channels
*/
+#include <config.h>
#include <stdlib.h>
#include <glib.h>
#include <stdio.h>
#include <string.h>
-#include "libsigrok.h"
+#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"
#define LOG_PREFIX "input/vcd"
#define DEFAULT_NUM_CHANNELS 8
-#define CHUNKSIZE 1024
+#define CHUNKSIZE (1024 * 1024)
struct context {
gboolean started;
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;
};
struct vcd_channel {
gchar *identifier;
};
-
/*
* Reads a single VCD section from input file and parses it to name/contents.
* e.g. $timescale 1ps $end => "timescale" "1ps"
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);
+ 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);
+
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;
return status;
return status ? SR_OK : SR_ERR;
}
-/* 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 = CHUNKSIZE / 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;
- logic.length = sizeof(uint64_t) * chunksize;
+ 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--;
+ }
- sr_session_send(sdi, &packet);
- count -= chunksize;
+ if (inc->samples_in_buffer == samples_per_chunk)
+ send_buffer(in);
}
}
struct context *inc;
struct vcd_channel *vcd_ch;
GSList *l;
- uint64_t timestamp, prev_timestamp, prev_values;
+ uint64_t timestamp, prev_timestamp;
unsigned int bit, i, j;
char **tokens;
inc = in->priv;
- prev_timestamp = prev_values = 0;
+ prev_timestamp = 0;
/* Read one space-delimited token at a time. */
tokens = g_strsplit_set(data, " \t\r\n", 0);
sr_dbg("New timestamp: %" PRIu64, timestamp);
/* Generate samples from prev_timestamp up to timestamp - 1. */
- send_samples(in->sdi, prev_values, timestamp - prev_timestamp);
+ add_samples(in, timestamp - prev_timestamp);
prev_timestamp = timestamp;
}
} else if (tokens[i][0] == '$' && tokens[i][1] != '\0') {
break;
}
} else if (strchr("bBrR", tokens[i][0]) != NULL) {
- /* A vector value, not supported yet. */
- break;
+ sr_dbg("Vector values not supported yet");
+ if (!tokens[++i])
+ /* No tokens left, bail out */
+ break;
+ else
+ /* Process next token */
+ continue;
} else if (strchr("01xXzZ", tokens[i][0]) != NULL) {
/* A new 1-bit sample value */
bit = (tokens[i][0] == '1');
* there was whitespace after the bit, the next token.
*/
if (tokens[i][1] == '\0') {
- if (!tokens[++i])
- /* Missing identifier */
- continue;
+ if (!tokens[++i]) {
+ sr_dbg("Identifier missing!");
+ break;
+ }
} else {
for (j = 1; tokens[i][j]; j++)
tokens[i][j - 1] = tokens[i][j];
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)
- prev_values |= (uint64_t)1 << j;
+ inc->current_levels[byte_idx] |= (uint8_t)1 << bit_idx;
else
- prev_values &= ~((uint64_t)1 << j);
+ inc->current_levels[byte_idx] &= ~((uint8_t)1 << bit_idx);
break;
}
}
static int init(struct sr_input *in, GHashTable *options)
{
- struct sr_channel *ch;
int num_channels, i;
char name[16];
struct context *inc;
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;
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);
- ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, name);
- in->sdi->channels = g_slist_append(in->sdi->channels, ch);
+ sr_channel_new(in->sdi, i, SR_CHANNEL_LOGIC, TRUE, name);
}
return SR_OK;
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;
struct context *inc;
int ret;
+ inc = in->priv;
+
if (in->sdi_ready)
ret = process_buffer(in);
else
ret = SR_OK;
- inc = in->priv;
+ /* 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);
inc = in->priv;
g_slist_free_full(inc->channels, free_channel);
+ g_free(inc->buffer);
+ inc->buffer = NULL;
+ g_free(inc->current_levels);
+ inc->current_levels = NULL;
}
static struct sr_option options[] = {
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));
projects / libsigrok.git / blobdiff