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;
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))
r = snprintf(o, 30, "%"PRIu64" MHz", samplerate / 1000000);
r = snprintf(o, 30, "%" PRIu64 " MHz", samplerate / 1000000);
else if (samplerate >= KHZ(1))
r = snprintf(o, 30, "%"PRIu64" KHz", samplerate / 1000);
r = snprintf(o, 30, "%" PRIu64 " KHz", samplerate / 1000);
else
r = snprintf(o, 30, "%"PRIu64" Hz", samplerate);
r = snprintf(o, 30, "%" PRIu64 " Hz", samplerate);
if (r < 0) {
/* 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;
event_type = event_type;
switch(event_type) {
switch (event_type) {
case DF_TRIGGER:
break;
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. */
samplerate = *((uint64_t *) o->device->plugin->get_device_info(
o->device->plugin_index, DI_CUR_SAMPLERATE));
if ((samplerate_s = sigrok_samplerate_string(samplerate)) == NULL)
return -1; // FIXME
return -1; /* FIXME */
/* Columns / channels */
wbuf[0] = '\0';
@ -108,11 +108,11 @@ static int event(struct output *o, int event_type, char **data_out,
int outlen = 1; /* FIXME */
ctx = o->internal;
switch(event_type) {
switch (event_type) {
case DF_TRIGGER:
break;
case DF_END:
outbuf = calloc(1, 1); // FIXME
outbuf = calloc(1, 1); /* FIXME */
if (outbuf == NULL)
return SIGROK_ERR_MALLOC;
*data_out = outbuf;
@ -135,7 +135,7 @@ static int data(struct output *o, char *data_in, uint64_t length_in,
ctx = o->internal;
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)
return SIGROK_ERR_MALLOC;
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? */
for (offset = 0; offset <= length_in - ctx->unitsize;
offset += ctx->unitsize) {
offset += ctx->unitsize) {
memcpy(&sample, data_in + offset, ctx->unitsize);
/* The first column is a counter (needed for gnuplot). */
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. */
for (p = 0; p < ctx->num_enabled_probes; p++) {

19
output/output_skeleton.c
View File

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

146
output/output_text.c
View File

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