BLAHAJ
/
libsigrok
10
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

output/vcd: Support getting samplerate from meta packets.

This commit is contained in:
Bert Vermeulen 2014-04-30 07:40:56 -07:00
parent 83023573d9
commit 6cb45d96c8
1 changed files with 124 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
output/vcd.c
View File

@ -31,9 +31,10 @@
struct context { struct context {
int num_enabled_channels; int num_enabled_channels;
GArray *channelindices; GArray *channelindices;
GString *header;
uint8_t *prevsample; uint8_t *prevsample;
gboolean header_done;
int period; int period;
int *channel_index;
uint64_t samplerate; uint64_t samplerate;
uint64_t samplecount; uint64_t samplecount;
}; };
@ -46,62 +47,81 @@ static int init(struct sr_output *o)
struct context *ctx; struct context *ctx;
struct sr_channel *ch; struct sr_channel *ch;
GSList *l; GSList *l;
GVariant *gvar; int num_enabled_channels, i;
int num_channels, i;
char *samplerate_s, *frequency_s, *timestamp;
time_t t;
if (!(ctx = g_malloc0(sizeof(struct context)))) {
sr_err("%s: ctx malloc failed", __func__);
return SR_ERR_MALLOC;
}
o->internal = ctx;
ctx->num_enabled_channels = 0;
ctx->channelindices = g_array_new(FALSE, FALSE, sizeof(int));
num_enabled_channels = 0;
for (l = o->sdi->channels; l; l = l->next) { for (l = o->sdi->channels; l; l = l->next) {
ch = l->data; ch = l->data;
if (ch->type != SR_CHANNEL_LOGIC) if (ch->type != SR_CHANNEL_LOGIC)
continue; continue;
if (!ch->enabled) if (!ch->enabled)
continue; continue;
ctx->channelindices = g_array_append_val( num_enabled_channels++;
ctx->channelindices, ch->index);
ctx->num_enabled_channels++;
} }
if (ctx->num_enabled_channels > 94) { if (num_enabled_channels > 94) {
sr_err("VCD only supports 94 channels."); sr_err("VCD only supports 94 channels.");
return SR_ERR; return SR_ERR;
} }
ctx->header = g_string_sized_new(512); ctx = g_malloc0(sizeof(struct context));
o->internal = ctx;
ctx->num_enabled_channels = num_enabled_channels;
ctx->channel_index = g_malloc(sizeof(int) * ctx->num_enabled_channels);
/* Once more to map the enabled channels. */
for (i = 0, l = o->sdi->channels; l; l = l->next) {
ch = l->data;
if (ch->type != SR_CHANNEL_LOGIC)
continue;
if (!ch->enabled)
continue;
ctx->channel_index[i++] = ch->index;
}
return SR_OK;
}
static GString *gen_header(struct sr_output *o)
{
struct context *ctx;
struct sr_channel *ch;
GVariant *gvar;
GString *header;
GSList *l;
time_t t;
int num_channels, i;
char *samplerate_s, *frequency_s, *timestamp;
ctx = o->internal;
header = g_string_sized_new(512);
num_channels = g_slist_length(o->sdi->channels); num_channels = g_slist_length(o->sdi->channels);
/* timestamp */ /* timestamp */
t = time(NULL); t = time(NULL);
timestamp = g_strdup(ctime(&t)); timestamp = g_strdup(ctime(&t));
timestamp[strlen(timestamp)-1] = 0; timestamp[strlen(timestamp)-1] = 0;
g_string_printf(ctx->header, "$date %s $end\n", timestamp); g_string_printf(header, "$date %s $end\n", timestamp);
g_free(timestamp); g_free(timestamp);
/* generator */ /* generator */
g_string_append_printf(ctx->header, "$version %s %s $end\n", g_string_append_printf(header, "$version %s %s $end\n",
PACKAGE, PACKAGE_VERSION); PACKAGE, PACKAGE_VERSION);
g_string_append_printf(header, "$comment\n Acquisition with "
"%d/%d channels", ctx->num_enabled_channels, num_channels);
if (ctx->samplerate == 0) {
if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE, if (sr_config_get(o->sdi->driver, o->sdi, NULL, SR_CONF_SAMPLERATE,
&gvar) == SR_OK) { &gvar) == SR_OK) {
ctx->samplerate = g_variant_get_uint64(gvar); ctx->samplerate = g_variant_get_uint64(gvar);
g_variant_unref(gvar); g_variant_unref(gvar);
if (!((samplerate_s = sr_samplerate_string(ctx->samplerate)))) {
g_string_free(ctx->header, TRUE);
g_free(ctx);
return SR_ERR;
} }
g_string_append_printf(ctx->header, vcd_header_comment, }
ctx->num_enabled_channels, num_channels, samplerate_s); if (ctx->samplerate != 0) {
samplerate_s = sr_samplerate_string(ctx->samplerate);
g_string_append_printf(header, " at %s", samplerate_s);
g_free(samplerate_s); g_free(samplerate_s);
} }
g_string_append_printf(header, "\n$end\n");
/* timescale */ /* timescale */
/* VCD can only handle 1/10/100 (s - fs), so scale up first */ /* VCD can only handle 1/10/100 (s - fs), so scale up first */
@ -111,16 +131,12 @@ static int init(struct sr_output *o)
ctx->period = SR_MHZ(1); ctx->period = SR_MHZ(1);
else else
ctx->period = SR_KHZ(1); ctx->period = SR_KHZ(1);
if (!(frequency_s = sr_period_string(ctx->period))) { frequency_s = sr_period_string(ctx->period);
g_string_free(ctx->header, TRUE); g_string_append_printf(header, "$timescale %s $end\n", frequency_s);
g_free(ctx);
return SR_ERR;
}
g_string_append_printf(ctx->header, "$timescale %s $end\n", frequency_s);
g_free(frequency_s); g_free(frequency_s);
/* scope */ /* scope */
g_string_append_printf(ctx->header, "$scope module %s $end\n", PACKAGE); g_string_append_printf(header, "$scope module %s $end\n", PACKAGE);
/* Wires / channels */ /* Wires / channels */
for (i = 0, l = o->sdi->channels; l; l = l->next, i++) { for (i = 0, l = o->sdi->channels; l; l = l->next, i++) {
@ -129,20 +145,22 @@ static int init(struct sr_output *o)
continue; continue;
if (!ch->enabled) if (!ch->enabled)
continue; continue;
g_string_append_printf(ctx->header, "$var wire 1 %c %s $end\n", g_string_append_printf(header, "$var wire 1 %c %s $end\n",
(char)('!' + i), ch->name); (char)('!' + i), ch->name);
} }
g_string_append(ctx->header, "$upscope $end\n" g_string_append(header, "$upscope $end\n$enddefinitions $end\n");
"$enddefinitions $end\n");
return SR_OK; return header;
} }
static int receive(struct sr_output *o, const struct sr_datafeed_packet *packet, static int receive(struct sr_output *o, const struct sr_datafeed_packet *packet,
GString **out) GString **out)
{ {
const struct sr_datafeed_meta *meta;
const struct sr_datafeed_logic *logic; const struct sr_datafeed_logic *logic;
const struct sr_config *src;
GSList *l;
struct context *ctx; struct context *ctx;
unsigned int i; unsigned int i;
int p, curbit, prevbit, index; int p, curbit, prevbit, index;
@ -154,33 +172,29 @@ static int receive(struct sr_output *o, const struct sr_datafeed_packet *packet,
return SR_ERR_BUG; return SR_ERR_BUG;
ctx = o->internal; ctx = o->internal;
if (ctx->header) { switch (packet->type) {
/* The header is still here, this must be the first packet. */ case SR_DF_META:
*out = ctx->header; meta = packet->payload;
ctx->header = NULL; for (l = meta->config; l; l = l->next) {
ctx->samplecount = 0; src = l->data;
if (src->key != SR_CONF_SAMPLERATE)
continue;
ctx->samplerate = g_variant_get_uint64(src->data);
}
break;
case SR_DF_LOGIC:
logic = packet->payload;
if (!ctx->header_done) {
*out = gen_header(o);
ctx->header_done = TRUE;
} else { } else {
*out = g_string_sized_new(512); *out = g_string_sized_new(512);
} }
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;
}
logic = packet->payload;
if (!ctx->prevsample) { if (!ctx->prevsample) {
/* Can't allocate this until we know the stream's unitsize. */ /* Can't allocate this until we know the stream's unitsize. */
if (!(ctx->prevsample = g_malloc0(logic->unitsize))) { ctx->prevsample = g_malloc0(logic->unitsize);
g_free(ctx);
sr_err("%s: ctx->prevsample malloc failed", __func__);
return SR_ERR_MALLOC;
}
} }
for (i = 0; i <= logic->length - logic->unitsize; i += logic->unitsize) { for (i = 0; i <= logic->length - logic->unitsize; i += logic->unitsize) {
@ -188,7 +202,7 @@ static int receive(struct sr_output *o, const struct sr_datafeed_packet *packet,
timestamp_written = FALSE; timestamp_written = FALSE;
for (p = 0; p < ctx->num_enabled_channels; p++) { for (p = 0; p < ctx->num_enabled_channels; p++) {
index = g_array_index(ctx->channelindices, int, p); index = ctx->channel_index[p];
curbit = ((unsigned)sample[index / 8] curbit = ((unsigned)sample[index / 8]
>> (index % 8)) & 1; >> (index % 8)) & 1;
@ -219,6 +233,14 @@ static int receive(struct sr_output *o, const struct sr_datafeed_packet *packet,
ctx->samplecount++; ctx->samplecount++;
memcpy(ctx->prevsample, sample, logic->unitsize); memcpy(ctx->prevsample, sample, logic->unitsize);
} }
break;
case SR_DF_END:
/* Write final timestamp as length indicator. */
*out = g_string_sized_new(512);
g_string_printf(*out, "#%.0f\n",
(double)ctx->samplecount / ctx->samplerate * ctx->period);
break;
}
return SR_OK; return SR_OK;
} }
@ -232,7 +254,7 @@ static int cleanup(struct sr_output *o)
ctx = o->internal; ctx = o->internal;
g_free(ctx->prevsample); g_free(ctx->prevsample);
g_array_free(ctx->channelindices, TRUE); g_free(ctx->channel_index);
g_free(ctx); g_free(ctx);
return SR_OK; return SR_OK;