* - 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"
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') {
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;
- inc = g_malloc0(sizeof(struct context));
-
num_channels = g_variant_get_int32(g_hash_table_lookup(options, "numchannels"));
if (num_channels < 1) {
sr_err("Invalid value for numchannels: must be at least 1.");
return SR_ERR_ARG;
}
- if (num_channels > 64) {
- sr_err("No more than 64 channels supported.");
- return SR_ERR_ARG;
- }
+ inc = in->priv = g_malloc0(sizeof(struct context));
inc->maxchannels = num_channels;
inc->downsample = g_variant_get_int32(g_hash_table_lookup(options, "downsample"));
inc->skip = g_variant_get_int32(g_hash_table_lookup(options, "skip"));
inc->skip /= inc->downsample;
- in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL);
+ 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;
return FALSE;
}
-static int receive(const struct sr_input *in, GString *buf)
+static int process_buffer(struct sr_input *in)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
uint64_t samplerate;
char *p;
- g_string_append_len(in->buf, buf->str, buf->len);
-
inc = in->priv;
- if (!inc->got_header) {
- if (!have_header(in->buf))
- return SR_OK;
- if (!parse_header(in, in->buf) != SR_OK)
- /* There was a header in there, but it was malformed. */
- return SR_ERR;
-
+ if (!inc->started) {
std_session_send_df_header(in->sdi, LOG_PREFIX);
- inc->started = TRUE;
packet.type = SR_DF_META;
packet.payload = &meta;
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
sr_config_free(src);
+
+ inc->started = TRUE;
}
while ((p = g_strrstr_len(in->buf->str, in->buf->len, "\n"))) {
return SR_OK;
}
-static int cleanup(struct sr_input *in)
+static int receive(struct sr_input *in, GString *buf)
+{
+ struct context *inc;
+ int ret;
+
+ g_string_append_len(in->buf, buf->str, buf->len);
+
+ inc = in->priv;
+ if (!inc->got_header) {
+ if (!have_header(in->buf))
+ return SR_OK;
+ if (!parse_header(in, in->buf))
+ /* There was a header in there, but it was malformed. */
+ return SR_ERR;
+
+ in->sdi_ready = TRUE;
+ /* sdi is ready, notify frontend. */
+ return SR_OK;
+ }
+
+ ret = process_buffer(in);
+
+ return ret;
+}
+
+static int end(struct sr_input *in)
{
struct sr_datafeed_packet packet;
struct context *inc;
+ int ret;
inc = in->priv;
+
+ if (in->sdi_ready)
+ ret = process_buffer(in);
+ else
+ ret = SR_OK;
+
+ /* Send any samples that haven't been sent yet. */
+ send_buffer(in);
+
if (inc->started) {
- /* End of stream. */
packet.type = SR_DF_END;
sr_session_send(in->sdi, &packet);
}
- g_slist_free_full(inc->channels, free_channel);
- g_free(inc);
- in->priv = NULL;
+ return ret;
+}
- return SR_OK;
+static void cleanup(struct sr_input *in)
+{
+ struct context *inc;
+
+ 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));
.id = "vcd",
.name = "VCD",
.desc = "Value Change Dump",
+ .exts = (const char*[]){"vcd", NULL},
.metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
.options = get_options,
.format_match = format_match,
.init = init,
.receive = receive,
+ .end = end,
.cleanup = cleanup,
};
projects / libsigrok.git / blobdiff