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

output: Coding style fixes.

This commit is contained in:
Uwe Hermann 2010-04-15 20:36:04 +02:00
parent 62c8202582
commit 99c1fc59ed
6 changed files with 104 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
output/common.c
View File

@ -42,13 +42,13 @@ char *sigrok_samplerate_string(uint64_t samplerate)
return NULL; return NULL;
if (samplerate >= GHZ(1)) if (samplerate >= GHZ(1))
r = snprintf(o, 30, "%"PRIu64" GHz", samplerate / 1000000000); r = snprintf(o, 30, "%" PRIu64 " GHz", samplerate / 1000000000);
else if (samplerate >= MHZ(1)) else if (samplerate >= MHZ(1))
r = snprintf(o, 30, "%"PRIu64" MHz", samplerate / 1000000); r = snprintf(o, 30, "%" PRIu64 " MHz", samplerate / 1000000);
else if (samplerate >= KHZ(1)) else if (samplerate >= KHZ(1))
r = snprintf(o, 30, "%"PRIu64" KHz", samplerate / 1000); r = snprintf(o, 30, "%" PRIu64 " KHz", samplerate / 1000);
else else
r = snprintf(o, 30, "%"PRIu64" Hz", samplerate); r = snprintf(o, 30, "%" PRIu64 " Hz", samplerate);
if (r < 0) { if (r < 0) {
/* Something went wrong... */ /* Something went wrong... */

2
output/output_binary.c
View File

@ -43,7 +43,7 @@ static int event(struct output *o, int event_type, char **data_out,
o = o; o = o;
event_type = event_type; event_type = event_type;
switch(event_type) { switch (event_type) {
case DF_TRIGGER: case DF_TRIGGER:
break; break;
case DF_END: case DF_END:

14
output/output_gnuplot.c
View File

@ -76,9 +76,9 @@ static int init(struct output *o)
/* TODO: Handle num_probes == 0, too many probes, etc. */ /* TODO: Handle num_probes == 0, too many probes, etc. */
samplerate = *((uint64_t *) o->device->plugin->get_device_info( samplerate = *((uint64_t *) o->device->plugin->get_device_info(
o->device->plugin_index, DI_CUR_SAMPLERATE)); o->device->plugin_index, DI_CUR_SAMPLERATE));
if ((samplerate_s = sigrok_samplerate_string(samplerate)) == NULL) if ((samplerate_s = sigrok_samplerate_string(samplerate)) == NULL)
return -1; // FIXME return -1; /* FIXME */
/* Columns / channels */ /* Columns / channels */
wbuf[0] = '\0'; wbuf[0] = '\0';
@ -108,11 +108,11 @@ static int event(struct output *o, int event_type, char **data_out,
int outlen = 1; /* FIXME */ int outlen = 1; /* FIXME */
ctx = o->internal; ctx = o->internal;
switch(event_type) { switch (event_type) {
case DF_TRIGGER: case DF_TRIGGER:
break; break;
case DF_END: case DF_END:
outbuf = calloc(1, 1); // FIXME outbuf = calloc(1, 1); /* FIXME */
if (outbuf == NULL) if (outbuf == NULL)
return SIGROK_ERR_MALLOC; return SIGROK_ERR_MALLOC;
*data_out = outbuf; *data_out = outbuf;
@ -135,7 +135,7 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
ctx = o->internal; ctx = o->internal;
outsize = strlen(ctx->header); outsize = strlen(ctx->header);
outbuf = calloc(1, outsize + 1 + 10000); // FIXME: Use realloc(). outbuf = calloc(1, outsize + 1 + 10000); /* FIXME: Use realloc(). */
if (outbuf == NULL) if (outbuf == NULL)
return SIGROK_ERR_MALLOC; return SIGROK_ERR_MALLOC;
if (ctx->header) { if (ctx->header) {
@ -150,12 +150,12 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
/* TODO: Are disabled probes handled correctly? */ /* TODO: Are disabled probes handled correctly? */
for (offset = 0; offset <= length_in - ctx->unitsize; for (offset = 0; offset <= length_in - ctx->unitsize;
offset += ctx->unitsize) { offset += ctx->unitsize) {
memcpy(&sample, data_in + offset, ctx->unitsize); memcpy(&sample, data_in + offset, ctx->unitsize);
/* The first column is a counter (needed for gnuplot). */ /* The first column is a counter (needed for gnuplot). */
c = outbuf + strlen(outbuf); c = outbuf + strlen(outbuf);
sprintf(c, "%"PRIu64"\t\t", count++); sprintf(c, "%" PRIu64 "\t\t", count++);
/* The next columns are the values of all channels. */ /* The next columns are the values of all channels. */
for (p = 0; p < ctx->num_enabled_probes; p++) { for (p = 0; p < ctx->num_enabled_probes; p++) {

19
output/output_skeleton.c
View File

@ -18,36 +18,29 @@
*/ */
#include <stdint.h> #include <stdint.h>
#include "sigrok.h" #include <sigrok.h>
static int init(struct output *o) static int init(struct output *o)
{ {
return 0; return 0;
} }
static int data(struct output *o, char *data_in, uint64_t length_in,
static int data(struct output *o, char *data_in, uint64_t length_in, char **data_out, uint64_t *length_out) char **data_out, uint64_t *length_out)
{ {
return SIGROK_OK; return SIGROK_OK;
} }
static int event(struct output *o, int event_type, char **data_out,
static int event(struct output *o, int event_type, char **data_out, uint64_t *length_out) uint64_t *length_out)
{ {
return SIGROK_OK; return SIGROK_OK;
} }
struct output_format output_foo = { struct output_format output_foo = {
"foo", "foo",
"The foo format", "The foo format",
init, init,
data, data,
event event,
}; };

146
output/output_text.c
View File

@ -39,33 +39,30 @@ struct context {
char *header; char *header;
}; };
static void flush_linebufs(struct context *ctx, char *outbuf) static void flush_linebufs(struct context *ctx, char *outbuf)
{ {
static int max_probename_len = 0; static int max_probename_len = 0;
int len, i; int len, i;
if(ctx->linebuf[0] == 0) if (ctx->linebuf[0] == 0)
return; return;
if(max_probename_len == 0) { if (max_probename_len == 0) {
/* first time through */ /* First time through... */
for(i = 0; ctx->probelist[i]; i++) { for (i = 0; ctx->probelist[i]; i++) {
len = strlen(ctx->probelist[i]); len = strlen(ctx->probelist[i]);
if(len > max_probename_len) if (len > max_probename_len)
max_probename_len = len; max_probename_len = len;
} }
} }
for(i = 0; ctx->probelist[i]; i++) { for (i = 0; ctx->probelist[i]; i++) {
sprintf(outbuf + strlen(outbuf), "%*s:%s\n", max_probename_len, ctx->probelist[i], sprintf(outbuf + strlen(outbuf), "%*s:%s\n", max_probename_len,
ctx->linebuf + i * ctx->linebuf_len); ctx->probelist[i], ctx->linebuf + i * ctx->linebuf_len);
} }
memset(ctx->linebuf, 0, i * ctx->linebuf_len); memset(ctx->linebuf, 0, i * ctx->linebuf_len);
} }
static int init(struct output *o, int default_spl) static int init(struct output *o, int default_spl)
{ {
struct context *ctx; struct context *ctx;
@ -78,27 +75,32 @@ static int init(struct output *o, int default_spl)
ctx = malloc(sizeof(struct context)); ctx = malloc(sizeof(struct context));
o->internal = ctx; o->internal = ctx;
ctx->num_enabled_probes = 0; ctx->num_enabled_probes = 0;
for(l = o->device->probes; l; l = l->next) {
for (l = o->device->probes; l; l = l->next) {
probe = l->data; probe = l->data;
if(probe->enabled) if (probe->enabled)
ctx->probelist[ctx->num_enabled_probes++] = probe->name; ctx->probelist[ctx->num_enabled_probes++] = probe->name;
} }
ctx->probelist[ctx->num_enabled_probes] = 0; ctx->probelist[ctx->num_enabled_probes] = 0;
ctx->unitsize = (ctx->num_enabled_probes + 7) / 8; ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
ctx->line_offset = 0; ctx->line_offset = 0;
ctx->spl_cnt = 0; ctx->spl_cnt = 0;
if(o->param && o->param[0])
if (o->param && o->param[0])
ctx->samples_per_line = strtoul(o->param, NULL, 10); ctx->samples_per_line = strtoul(o->param, NULL, 10);
else else
ctx->samples_per_line = default_spl; ctx->samples_per_line = default_spl;
ctx->header = malloc(512); ctx->header = malloc(512);
num_probes = g_slist_length(o->device->probes); num_probes = g_slist_length(o->device->probes);
samplerate = *((uint64_t *) o->device->plugin->get_device_info(o->device->plugin_index, DI_CUR_SAMPLERATE)); samplerate = *((uint64_t *) o->device->plugin->get_device_info(
snprintf(ctx->header, 512, "Acquisition with %d/%d probes at ", ctx->num_enabled_probes, num_probes); o->device->plugin_index, DI_CUR_SAMPLERATE));
snprintf(ctx->header, 512, "Acquisition with %d/%d probes at ",
ctx->num_enabled_probes, num_probes);
if ((samplerate_s = sigrok_samplerate_string(samplerate)) == NULL) if ((samplerate_s = sigrok_samplerate_string(samplerate)) == NULL)
return -1; // FIXME return -1; /* FIXME */
snprintf(ctx->header + strlen(ctx->header), 512, "%s\n", samplerate_s); snprintf(ctx->header + strlen(ctx->header), 512, "%s\n", samplerate_s);
free(samplerate_s); free(samplerate_s);
@ -109,19 +111,20 @@ static int init(struct output *o, int default_spl)
return 0; return 0;
} }
static int event(struct output *o, int event_type, char **data_out,
static int event(struct output *o, int event_type, char **data_out, uint64_t *length_out) uint64_t *length_out)
{ {
struct context *ctx; struct context *ctx;
int outsize; int outsize;
char *outbuf; char *outbuf;
ctx = o->internal; ctx = o->internal;
switch(event_type) { switch (event_type) {
case DF_TRIGGER: case DF_TRIGGER:
break; break;
case DF_END: case DF_END:
outsize = ctx->num_enabled_probes * (ctx->samples_per_line + 20) + 512; outsize = ctx->num_enabled_probes
* (ctx->samples_per_line + 20) + 512;
outbuf = calloc(1, outsize); outbuf = calloc(1, outsize);
flush_linebufs(ctx, outbuf); flush_linebufs(ctx, outbuf);
*data_out = outbuf; *data_out = outbuf;
@ -134,16 +137,13 @@ static int event(struct output *o, int event_type, char **data_out, uint64_t *le
return SIGROK_OK; return SIGROK_OK;
} }
static int init_bits(struct output *o) static int init_bits(struct output *o)
{ {
return init(o, DEFAULT_BPL_BITS); return init(o, DEFAULT_BPL_BITS);
} }
static int data_bits(struct output *o, char *data_in, uint64_t length_in,
static int data_bits(struct output *o, char *data_in, uint64_t length_in, char **data_out, uint64_t *length_out) char **data_out, uint64_t *length_out)
{ {
struct context *ctx; struct context *ctx;
unsigned int outsize, offset, p; unsigned int outsize, offset, p;
@ -151,44 +151,48 @@ static int data_bits(struct output *o, char *data_in, uint64_t length_in, char *
char *outbuf; char *outbuf;
ctx = o->internal; ctx = o->internal;
outsize = length_in / ctx->unitsize * ctx->num_enabled_probes * ctx->samples_per_line + 512; outsize = length_in / ctx->unitsize * ctx->num_enabled_probes *
outbuf = calloc(1, outsize+1); ctx->samples_per_line + 512;
if(ctx->header) { outbuf = calloc(1, outsize + 1);
/* the header is still in here, we must be on the first data packet */ if (ctx->header) {
/* The header is still here, this must be the first packet. */
strncpy(outbuf, ctx->header, outsize); strncpy(outbuf, ctx->header, outsize);
free(ctx->header); free(ctx->header);
ctx->header = NULL; ctx->header = NULL;
} } else
else
outbuf[0] = 0; outbuf[0] = 0;
if(length_in >= ctx->unitsize) { if (length_in >= ctx->unitsize) {
for(offset = 0; offset <= length_in - ctx->unitsize; offset += ctx->unitsize) { for (offset = 0; offset <= length_in - ctx->unitsize;
offset += ctx->unitsize) {
memcpy(&sample, data_in + offset, ctx->unitsize); memcpy(&sample, data_in + offset, ctx->unitsize);
for(p = 0; p < ctx->num_enabled_probes; p++) { for (p = 0; p < ctx->num_enabled_probes; p++) {
if(sample & ((uint64_t) 1 << p)) if (sample & ((uint64_t) 1 << p))
ctx->linebuf[p * ctx->linebuf_len + ctx->line_offset] = '1'; ctx->linebuf[p * ctx->linebuf_len +
ctx->line_offset] = '1';
else else
ctx->linebuf[p * ctx->linebuf_len + ctx->line_offset] = '0'; ctx->linebuf[p * ctx->linebuf_len +
ctx->line_offset] = '0';
} }
ctx->line_offset++; ctx->line_offset++;
ctx->spl_cnt++; ctx->spl_cnt++;
/* space every 8th bit */ /* Add a space every 8th bit. */
if((ctx->spl_cnt & 7) == 0) { if ((ctx->spl_cnt & 7) == 0) {
for(p = 0; p < ctx->num_enabled_probes; p++) for (p = 0; p < ctx->num_enabled_probes; p++)
ctx->linebuf[p * ctx->linebuf_len + ctx->line_offset] = ' '; ctx->linebuf[p * ctx->linebuf_len +
ctx->line_offset] = ' ';
ctx->line_offset++; ctx->line_offset++;
} }
/* end of line */ /* End of line. */
if(ctx->spl_cnt >= ctx->samples_per_line) { if (ctx->spl_cnt >= ctx->samples_per_line) {
flush_linebufs(ctx, outbuf); flush_linebufs(ctx, outbuf);
ctx->line_offset = ctx->spl_cnt = 0; ctx->line_offset = ctx->spl_cnt = 0;
} }
} }
} else } else
g_message("short buffer (length_in=%"PRIu64")", length_in); g_message("short buffer (length_in=%" PRIu64 ")", length_in);
*data_out = outbuf; *data_out = outbuf;
*length_out = strlen(outbuf); *length_out = strlen(outbuf);
@ -196,16 +200,13 @@ static int data_bits(struct output *o, char *data_in, uint64_t length_in, char *
return SIGROK_OK; return SIGROK_OK;
} }
static int init_hex(struct output *o) static int init_hex(struct output *o)
{ {
return init(o, DEFAULT_BPL_BITS); return init(o, DEFAULT_BPL_BITS);
} }
static int data_hex(struct output *o, char *data_in, uint64_t length_in,
static int data_hex(struct output *o, char *data_in, uint64_t length_in, char **data_out, uint64_t *length_out) char **data_out, uint64_t *length_out)
{ {
struct context *ctx; struct context *ctx;
unsigned int outsize, offset, p; unsigned int outsize, offset, p;
@ -213,37 +214,40 @@ static int data_hex(struct output *o, char *data_in, uint64_t length_in, char **
char *outbuf; char *outbuf;
ctx = o->internal; ctx = o->internal;
outsize = length_in / ctx->unitsize * ctx->num_enabled_probes * ctx->samples_per_line + 512; outsize = length_in / ctx->unitsize * ctx->num_enabled_probes *
outbuf = calloc(1, outsize+1); ctx->samples_per_line + 512;
if(ctx->header) { outbuf = calloc(1, outsize + 1);
/* the header is still in here, we must be on the first data packet */ if (ctx->header) {
/* The header is still here, this must be the first packet. */
strncpy(outbuf, ctx->header, outsize); strncpy(outbuf, ctx->header, outsize);
free(ctx->header); free(ctx->header);
ctx->header = NULL; ctx->header = NULL;
} } else
else
outbuf[0] = 0; outbuf[0] = 0;
ctx->line_offset = 0; ctx->line_offset = 0;
for(offset = 0; offset <= length_in - ctx->unitsize; offset += ctx->unitsize) { for (offset = 0; offset <= length_in - ctx->unitsize;
offset += ctx->unitsize) {
memcpy(&sample, data_in + offset, ctx->unitsize); memcpy(&sample, data_in + offset, ctx->unitsize);
for(p = 0; p < ctx->num_enabled_probes; p++) { for (p = 0; p < ctx->num_enabled_probes; p++) {
ctx->linevalues[p] <<= 1; ctx->linevalues[p] <<= 1;
if(sample & ((uint64_t) 1 << p)) if (sample & ((uint64_t) 1 << p))
ctx->linevalues[p] |= 1; ctx->linevalues[p] |= 1;
sprintf(ctx->linebuf + (p * ctx->linebuf_len) + ctx->line_offset, "%.2x", ctx->linevalues[p]); sprintf(ctx->linebuf + (p * ctx->linebuf_len) +
ctx->line_offset, "%.2x", ctx->linevalues[p]);
} }
ctx->spl_cnt++; ctx->spl_cnt++;
/* space after every complete hex byte */ /* Add a space after every complete hex byte. */
if((ctx->spl_cnt & 7) == 0) { if ((ctx->spl_cnt & 7) == 0) {
for(p = 0; p < ctx->num_enabled_probes; p++) for (p = 0; p < ctx->num_enabled_probes; p++)
ctx->linebuf[p * ctx->linebuf_len + ctx->line_offset + 2] = ' '; ctx->linebuf[p * ctx->linebuf_len +
ctx->line_offset + 2] = ' ';
ctx->line_offset += 3; ctx->line_offset += 3;
} }
/* end of line */ /* End of line. */
if(ctx->spl_cnt >= ctx->samples_per_line) { if (ctx->spl_cnt >= ctx->samples_per_line) {
flush_linebufs(ctx, outbuf); flush_linebufs(ctx, outbuf);
ctx->line_offset = ctx->spl_cnt = 0; ctx->line_offset = ctx->spl_cnt = 0;
} }
@ -255,22 +259,18 @@ static int data_hex(struct output *o, char *data_in, uint64_t length_in, char **
return SIGROK_OK; return SIGROK_OK;
} }
struct output_format output_text_bits = { struct output_format output_text_bits = {
"bits", "bits",
"Text (bits)", "Text (bits)",
init_bits, init_bits,
data_bits, data_bits,
event event,
}; };
struct output_format output_text_hex = { struct output_format output_text_hex = {
"hex", "hex",
"Text (hexadecimal)", "Text (hexadecimal)",
init_hex, init_hex,
data_hex, data_hex,
event event,
}; };

23
output/output_vcd.c
View File

@ -81,17 +81,17 @@ static int init(struct output *o)
o->device->plugin_index, DI_CUR_SAMPLERATE)); o->device->plugin_index, DI_CUR_SAMPLERATE));
if ((samplerate_s = sigrok_samplerate_string(samplerate)) == NULL) if ((samplerate_s = sigrok_samplerate_string(samplerate)) == NULL)
return -1; // FIXME return -1; /* FIXME */
/* Wires / channels */ /* Wires / channels */
wbuf[0] = '\0'; wbuf[0] = '\0';
for (i = 0; i < ctx->num_enabled_probes; i++) { for (i = 0; i < ctx->num_enabled_probes; i++) {
c = (char *)&wbuf + strlen((char *)&wbuf); c = (char *)&wbuf + strlen((char *)&wbuf);
sprintf(c, "$var wire 1 %c channel%s $end\n", sprintf(c, "$var wire 1 %c channel%s $end\n",
(char)('!' + i), ctx->probelist[i]); (char)('!' + i), ctx->probelist[i]);
} }
/* TODO: date: File or signals? Make y/n configurable. */ /* TODO: Date: File or signals? Make y/n configurable. */
b = snprintf(ctx->header, MAX_HEADER_LEN, vcd_header, "TODO: Date", b = snprintf(ctx->header, MAX_HEADER_LEN, vcd_header, "TODO: Date",
PACKAGE_STRING, ctx->num_enabled_probes, num_probes, PACKAGE_STRING, ctx->num_enabled_probes, num_probes,
samplerate_s, 1, "ns", PACKAGE, (char *)&wbuf); samplerate_s, 1, "ns", PACKAGE, (char *)&wbuf);
@ -114,7 +114,7 @@ static int event(struct output *o, int event_type, char **data_out,
int outlen; int outlen;
ctx = o->internal; ctx = o->internal;
switch(event_type) { switch (event_type) {
case DF_TRIGGER: case DF_TRIGGER:
break; break;
case DF_END: case DF_END:
@ -144,7 +144,7 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
ctx = o->internal; ctx = o->internal;
outsize = strlen(ctx->header); outsize = strlen(ctx->header);
outbuf = calloc(1, outsize + 1 + 10000); // FIXME: Use realloc(). outbuf = calloc(1, outsize + 1 + 10000); /* FIXME: Use realloc(). */
if (outbuf == NULL) if (outbuf == NULL)
return SIGROK_ERR_MALLOC; return SIGROK_ERR_MALLOC;
if (ctx->header) { if (ctx->header) {
@ -159,15 +159,17 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
/* TODO: Are disabled probes handled correctly? */ /* TODO: Are disabled probes handled correctly? */
for (offset = 0; offset <= length_in - ctx->unitsize; for (offset = 0; offset <= length_in - ctx->unitsize;
offset += ctx->unitsize) { offset += ctx->unitsize) {
memcpy(&sample, data_in + offset, ctx->unitsize); memcpy(&sample, data_in + offset, ctx->unitsize);
for (p = 0; p < ctx->num_enabled_probes; p++) { for (p = 0; p < ctx->num_enabled_probes; p++) {
curbit = (sample & ((uint64_t) (1 << p))) != 0; curbit = (sample & ((uint64_t) (1 << p))) != 0;
if (offset == 0) { if (offset == 0) {
prevbit = ~curbit; prevbit = ~curbit;
} else { } else {
memcpy(&prevsample, data_in + offset - 1, ctx->unitsize); memcpy(&prevsample, data_in + offset - 1,
prevbit = (prevsample & ((uint64_t) (1 << p))) != 0; ctx->unitsize);
prevbit =
(prevsample & ((uint64_t) (1 << p))) != 0;
} }
if (prevbit != curbit) { if (prevbit != curbit) {
@ -176,11 +178,12 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
sprintf(c, "#%i\n", offset * 1 /* TODO */); sprintf(c, "#%i\n", offset * 1 /* TODO */);
c = outbuf + strlen(outbuf); c = outbuf + strlen(outbuf);
sprintf(c, "%i%c\n", curbit, (char)('!' + p /* FIXME? */)); sprintf(c, "%i%c\n", curbit,
(char)('!' + p /* FIXME? */));
} }
} }
/* TODO: Do a realloc() here if strlen(outbuf) is almost "full"... */ /* TODO: Use realloc() if strlen(outbuf) is almost "full"... */
} }
*data_out = outbuf; *data_out = outbuf;