X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Finput%2Fvcd.c;h=0cf495e181116abb99e7a0581ceaa4ff4a6f414e;hb=db0e5c999df2872e9be422a6ec48920eb3f4eb3f;hp=62b9a090086f55d4c8dbb6fda98878605ed27c2d;hpb=4f979115a4206bc1ff72c0319a340cbcad0f4b06;p=libsigrok.git diff --git a/src/input/vcd.c b/src/input/vcd.c index 62b9a090..0cf495e1 100644 --- a/src/input/vcd.c +++ b/src/input/vcd.c @@ -57,17 +57,18 @@ * - more than 64 channels */ +#include #include #include #include #include -#include "libsigrok.h" +#include #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; @@ -80,6 +81,10 @@ struct context { 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 { @@ -87,7 +92,6 @@ 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" @@ -228,12 +232,22 @@ static gboolean parse_header(const struct sr_input *in, GString *buf) 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; @@ -260,34 +274,57 @@ static int format_match(GHashTable *metadata) 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); } } @@ -297,12 +334,12 @@ 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, 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); @@ -343,7 +380,7 @@ static void parse_contents(const struct sr_input *in, char *data) 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') { @@ -386,10 +423,12 @@ static void parse_contents(const struct sr_input *in, char *data) 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; } } @@ -404,22 +443,16 @@ static void parse_contents(const struct sr_input *in, char *data) 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")); @@ -430,13 +463,14 @@ static int init(struct sr_input *in, GHashTable *options) 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; @@ -458,7 +492,7 @@ static gboolean have_header(GString *buf) 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; @@ -467,18 +501,9 @@ static int receive(const struct sr_input *in, GString *buf) 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; @@ -487,6 +512,8 @@ static int receive(const struct sr_input *in, GString *buf) 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"))) { @@ -500,23 +527,65 @@ static int receive(const struct sr_input *in, GString *buf) 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[] = { @@ -527,7 +596,7 @@ 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)); @@ -543,10 +612,12 @@ SR_PRIV struct sr_input_module input_vcd = { .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, };