X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=output%2Fvcd.c;h=7df345213250f2bc407d3821ba28c45aa0a6ea3d;hb=91aea754aaed0f0f2a6fc4b2b875f0d0b7c01f8e;hp=c15e9f077855a5402ce7f5accf1ce372b4668227;hpb=0da5b6a9f5a119ab485ed3dba08aeb4a3ad2c8f4;p=libsigrok.git diff --git a/output/vcd.c b/output/vcd.c index c15e9f07..7df34521 100644 --- a/output/vcd.c +++ b/output/vcd.c @@ -1,8 +1,8 @@ /* - * This file is part of the sigrok project. + * This file is part of the libsigrok project. * * Copyright (C) 2010 Uwe Hermann - * Copyright (C) 2011 Bert Vermeulen + * Copyright (C) 2013 Bert Vermeulen * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -22,77 +22,87 @@ #include #include #include -#include "sigrok.h" -#include "sigrok-internal.h" -#include "config.h" +#include "config.h" /* Needed for PACKAGE and others. */ +#include "libsigrok.h" +#include "libsigrok-internal.h" + +#define LOG_PREFIX "output/vcd" struct context { int num_enabled_probes; - int unitsize; - char *probelist[65]; - int *prevbits; + GArray *probeindices; GString *header; - uint64_t prevsample; + uint8_t *prevsample; int period; uint64_t samplerate; + uint64_t samplecount; + unsigned int unitsize; }; -static const char *vcd_header_comment = "\ -$comment\n Acquisition with %d/%d probes at %s\n$end\n"; +static const char *const vcd_header_comment = + "$comment\n Acquisition with %d/%d probes at %s\n$end\n"; static int init(struct sr_output *o) { struct context *ctx; - struct sr_probe *probe; + struct sr_channel *probe; GSList *l; + GVariant *gvar; int num_probes, i; char *samplerate_s, *frequency_s, *timestamp; time_t t; - if (!(ctx = calloc(1, sizeof(struct context)))) + if (!(ctx = g_try_malloc0(sizeof(struct context)))) { + sr_err("%s: ctx malloc failed", __func__); return SR_ERR_MALLOC; + } o->internal = ctx; ctx->num_enabled_probes = 0; + ctx->probeindices = g_array_new(FALSE, FALSE, sizeof(int)); - for (l = o->device->probes; l; l = l->next) { + for (l = o->sdi->probes; l; l = l->next) { probe = l->data; + if (probe->type != SR_PROBE_LOGIC) + continue; if (!probe->enabled) continue; - ctx->probelist[ctx->num_enabled_probes++] = probe->name; + ctx->probeindices = g_array_append_val( + ctx->probeindices, probe->index); + ctx->num_enabled_probes++; } if (ctx->num_enabled_probes > 94) { - sr_warn("VCD only supports 94 probes."); + sr_err("VCD only supports 94 probes."); return SR_ERR; } - ctx->probelist[ctx->num_enabled_probes] = 0; ctx->unitsize = (ctx->num_enabled_probes + 7) / 8; ctx->header = g_string_sized_new(512); - num_probes = g_slist_length(o->device->probes); + num_probes = g_slist_length(o->sdi->probes); /* timestamp */ t = time(NULL); - timestamp = strdup(ctime(&t)); + timestamp = g_strdup(ctime(&t)); timestamp[strlen(timestamp)-1] = 0; g_string_printf(ctx->header, "$date %s $end\n", timestamp); - free(timestamp); + g_free(timestamp); /* generator */ g_string_append_printf(ctx->header, "$version %s %s $end\n", PACKAGE, PACKAGE_VERSION); - if (o->device->plugin && sr_device_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { - ctx->samplerate = *((uint64_t *) o->device->plugin->get_device_info( - o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); + if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE, + &gvar) == SR_OK) { + ctx->samplerate = g_variant_get_uint64(gvar); + g_variant_unref(gvar); if (!((samplerate_s = sr_samplerate_string(ctx->samplerate)))) { g_string_free(ctx->header, TRUE); - free(ctx); + g_free(ctx); return SR_ERR; } g_string_append_printf(ctx->header, vcd_header_comment, ctx->num_enabled_probes, num_probes, samplerate_s); - free(samplerate_s); + g_free(samplerate_s); } /* timescale */ @@ -105,110 +115,124 @@ static int init(struct sr_output *o) ctx->period = SR_KHZ(1); if (!(frequency_s = sr_period_string(ctx->period))) { g_string_free(ctx->header, TRUE); - free(ctx); + g_free(ctx); return SR_ERR; } g_string_append_printf(ctx->header, "$timescale %s $end\n", frequency_s); - free(frequency_s); + g_free(frequency_s); /* scope */ g_string_append_printf(ctx->header, "$scope module %s $end\n", PACKAGE); /* Wires / channels */ - for (i = 0; i < ctx->num_enabled_probes; i++) { + for (i = 0, l = o->sdi->probes; l; l = l->next, i++) { + probe = l->data; + if (probe->type != SR_PROBE_LOGIC) + continue; + if (!probe->enabled) + continue; g_string_append_printf(ctx->header, "$var wire 1 %c %s $end\n", - (char)('!' + i), ctx->probelist[i]); + (char)('!' + i), probe->name); } g_string_append(ctx->header, "$upscope $end\n" - "$enddefinitions $end\n$dumpvars\n"); + "$enddefinitions $end\n"); - if (!(ctx->prevbits = calloc(sizeof(int), num_probes))) { + if (!(ctx->prevsample = g_try_malloc0(ctx->unitsize))) { g_string_free(ctx->header, TRUE); - free(ctx); + g_free(ctx); + sr_err("%s: ctx->prevsample malloc failed", __func__); return SR_ERR_MALLOC; } return SR_OK; } -static int event(struct sr_output *o, int event_type, char **data_out, - uint64_t *length_out) -{ - struct context *ctx; - char *outbuf; - - ctx = o->internal; - switch (event_type) { - case SR_DF_END: - outbuf = strdup("$dumpoff\n$end\n"); - *data_out = outbuf; - *length_out = strlen(outbuf); - free(o->internal); - o->internal = NULL; - break; - default: - *data_out = NULL; - *length_out = 0; - break; - } - - return SR_OK; -} - -static int data(struct sr_output *o, const char *data_in, uint64_t length_in, - char **data_out, uint64_t *length_out) +static int receive(struct sr_output *o, const struct sr_dev_inst *sdi, + const struct sr_datafeed_packet *packet, GString **out) { + const struct sr_datafeed_logic *logic; struct context *ctx; unsigned int i; - int p, curbit, prevbit; - uint64_t sample; - static uint64_t samplecount = 0; - GString *out; - int first_sample = 0; + int p, curbit, prevbit, index; + uint8_t *sample; + gboolean timestamp_written; + + (void)sdi; + *out = NULL; + if (!o || !o->internal) + return SR_ERR_BUG; ctx = o->internal; - out = g_string_sized_new(512); if (ctx->header) { /* The header is still here, this must be the first packet. */ - g_string_append(out, ctx->header->str); - g_string_free(ctx->header, TRUE); + *out = ctx->header; ctx->header = NULL; - first_sample = 1; + ctx->samplecount = 0; + } else { + *out = g_string_sized_new(512); } - for (i = 0; i <= length_in - ctx->unitsize; i += ctx->unitsize) { - samplecount++; - - memcpy(&sample, data_in + i, ctx->unitsize); + if (packet->type != SR_DF_LOGIC) { + if (packet->type == SR_DF_END) + /* Write final timestamp as length indicator. */ + g_string_append_printf(*out, "#%.0f\n", + (double)ctx->samplecount / + ctx->samplerate * ctx->period); + return SR_OK; + } - if (first_sample) { - /* First packet. We neg to make sure sample is stored. */ - ctx->prevsample = ~sample; - first_sample = 0; - } + logic = packet->payload; + for (i = 0; i <= logic->length - logic->unitsize; i += logic->unitsize) { + sample = logic->data + i; + timestamp_written = FALSE; for (p = 0; p < ctx->num_enabled_probes; p++) { - curbit = (sample & ((uint64_t) (1 << p))) >> p; - prevbit = (ctx->prevsample & ((uint64_t) (1 << p))) >> p; + index = g_array_index(ctx->probeindices, int, p); + + curbit = ((unsigned)sample[index / 8] + >> (index % 8)) & 1; + prevbit = ((unsigned)ctx->prevsample[index / 8] + >> (index % 8)) & 1; /* VCD only contains deltas/changes of signals. */ - if (prevbit == curbit) + if (prevbit == curbit && ctx->samplecount > 0) continue; + /* Output timestamp of subsequent signal changes. */ + if (!timestamp_written) + g_string_append_printf(*out, "#%.0f", + (double)ctx->samplecount / + ctx->samplerate * ctx->period); + /* Output which signal changed to which value. */ - g_string_append_printf(out, "#%" PRIu64 "\n%i%c\n", - (uint64_t)(((float)samplecount / ctx->samplerate) - * ctx->period), curbit, (char)('!' + p)); + g_string_append_c(*out, ' '); + g_string_append_c(*out, '0' + curbit); + g_string_append_c(*out, '!' + p); + + timestamp_written = TRUE; } - ctx->prevsample = sample; + if (timestamp_written) + g_string_append_c(*out, '\n'); + + ctx->samplecount++; + memcpy(ctx->prevsample, sample, ctx->unitsize); } - *data_out = out->str; - *length_out = out->len; - g_string_free(out, FALSE); + return SR_OK; +} + +static int cleanup(struct sr_output *o) +{ + struct context *ctx; + + if (!o || !o->internal) + return SR_ERR_ARG; + + ctx = o->internal; + g_free(ctx); return SR_OK; } @@ -218,6 +242,6 @@ struct sr_output_format output_vcd = { .description = "Value Change Dump (VCD)", .df_type = SR_DF_LOGIC, .init = init, - .data = data, - .event = event, + .receive = receive, + .cleanup = cleanup, };