SR_PRIV int event(struct sr_output *o, int event_type, uint8_t **data_out, uint64_t *length_out) { struct context *ctx; int outsize; uint8_t *outbuf; ctx = o->internal; switch (event_type) { case SR_DF_TRIGGER: ctx->mark_trigger = ctx->spl_cnt; *data_out = NULL; *length_out = 0; break; case SR_DF_END: outsize = ctx->num_enabled_probes * (ctx->samples_per_line + 20) + 512; if (!(outbuf = g_try_malloc0(outsize))) { sr_err("text out: %s: outbuf malloc failed", __func__); return SR_ERR_MALLOC; } flush_linebufs(ctx, outbuf); *data_out = outbuf; *length_out = strlen((const char *)outbuf); g_free(o->internal); o->internal = NULL; break; default: *data_out = NULL; *length_out = 0; break; } return SR_OK; }
static int data_binary(struct output *o, char *data_in, uint64_t length_in, char **data_out, uint64_t *length_out) { struct context *ctx; int outsize, offset, bpl_offset, p; uint64_t sample; char *outbuf; ctx = o->internal; outsize = length_in / ctx->unitsize * ctx->num_enabled_probes * 3 + 512; outbuf = calloc(1, outsize+1); if(ctx->header) { /* the header is still in here, we must be on the first data packet */ strncpy(outbuf, ctx->header, outsize); free(ctx->header); ctx->header = NULL; } else outbuf[0] = 0; bpl_offset = 0; 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 + bpl_offset] = '1'; else ctx->linebuf[p * ctx->linebuf_len + bpl_offset] = '0'; } bpl_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 + bpl_offset] = ' '; bpl_offset++; } /* end of line */ if(ctx->spl_cnt >= ctx->samples_per_line) { flush_linebufs(ctx, o->device->probes, outbuf); bpl_offset = ctx->spl_cnt = 0; } } *data_out = outbuf; *length_out = strlen(outbuf); return SIGROK_OK; }
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) { case DF_TRIGGER: break; case DF_END: outsize = ctx->num_enabled_probes * (ctx->samples_per_line + 20) + 512; outbuf = calloc(1, outsize); flush_linebufs(ctx, o->device->probes, outbuf); *data_out = outbuf; *length_out = strlen(outbuf); free(o->internal); o->internal = NULL; break; } return SIGROK_OK; }
SR_PRIV int data_bits(struct sr_output *o, const uint8_t *data_in, uint64_t length_in, uint8_t **data_out, uint64_t *length_out) { struct context *ctx; unsigned int outsize, offset, p; int max_linelen; uint64_t sample; uint8_t *outbuf, c; ctx = o->internal; max_linelen = SR_MAX_PROBENAME_LEN + 3 + ctx->samples_per_line + ctx->samples_per_line / 8; /* * Calculate space needed for probes. Set aside 512 bytes for * extra output, e.g. trigger. */ outsize = 512 + (1 + (length_in / ctx->unitsize) / ctx->samples_per_line) * (ctx->num_enabled_probes * max_linelen); if (!(outbuf = g_try_malloc0(outsize + 1))) { sr_err("bits out: %s: outbuf malloc failed", __func__); return SR_ERR_MALLOC; } outbuf[0] = '\0'; if (ctx->header) { /* The header is still here, this must be the first packet. */ strncpy((char *)outbuf, ctx->header, outsize); g_free(ctx->header); ctx->header = NULL; /* Ensure first transition. */ memcpy(&ctx->prevsample, data_in, ctx->unitsize); ctx->prevsample = ~ctx->prevsample; } 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++) { c = (sample & ((uint64_t) 1 << p)) ? '1' : '0'; ctx->linebuf[p * ctx->linebuf_len + ctx->line_offset] = c; } ctx->line_offset++; ctx->spl_cnt++; /* 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) { flush_linebufs(ctx, outbuf); ctx->line_offset = ctx->spl_cnt = 0; ctx->mark_trigger = -1; } } } else { sr_info("bits out: short buffer (length_in=%" PRIu64 ")", length_in); } *data_out = outbuf; *length_out = strlen((const char *)outbuf); return SR_OK; }
int data_ascii(struct sr_output *o, const char *data_in, uint64_t length_in, char **data_out, uint64_t *length_out) { struct context *ctx; unsigned int outsize, offset, p; int max_linelen; uint64_t sample; char *outbuf; ctx = o->internal; max_linelen = SR_MAX_PROBENAME_LEN + 3 + ctx->samples_per_line + ctx->samples_per_line / 8; /* * Calculate space needed for probes. Set aside 512 bytes for * extra output, e.g. trigger. */ outsize = 512 + (1 + (length_in / ctx->unitsize) / ctx->samples_per_line) * (ctx->num_enabled_probes * max_linelen); if (!(outbuf = calloc(1, outsize + 1))) return SR_ERR_MALLOC; outbuf[0] = '\0'; 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; } if (length_in >= ctx->unitsize) { for (offset = 0; offset <= length_in - ctx->unitsize; offset += ctx->unitsize) { memcpy(&sample, data_in + offset, ctx->unitsize); char tmpval[ctx->num_enabled_probes]; for (p = 0; p < ctx->num_enabled_probes; p++) { uint64_t curbit = (sample & ((uint64_t) 1 << p)); uint64_t prevbit = (ctx->prevsample & ((uint64_t) 1 << p)); if (curbit < prevbit && ctx->line_offset > 0) { ctx->linebuf[p * ctx->linebuf_len + ctx->line_offset-1] = '\\'; } if (curbit > prevbit) { tmpval[p] = '/'; } else { if (curbit) tmpval[p] = '"'; else tmpval[p] = '.'; } } /* End of line. */ if (ctx->spl_cnt >= ctx->samples_per_line) { flush_linebufs(ctx, outbuf); ctx->line_offset = ctx->spl_cnt = 0; ctx->mark_trigger = -1; } for (p = 0; p < ctx->num_enabled_probes; p++) { ctx->linebuf[p * ctx->linebuf_len + ctx->line_offset] = tmpval[p]; } ctx->line_offset++; ctx->spl_cnt++; ctx->prevsample = sample; } } else { sr_info("short buffer (length_in=%" PRIu64 ")", length_in); } *data_out = outbuf; *length_out = strlen(outbuf); return SR_OK; }
SR_PRIV int data_hex(struct sr_output *o, const uint8_t *data_in, uint64_t length_in, uint8_t **data_out, uint64_t *length_out) { struct context *ctx; unsigned int outsize, offset, p; int max_linelen; const uint8_t *sample; uint8_t *outbuf; ctx = o->internal; max_linelen = SR_MAX_PROBENAME_LEN + 3 + ctx->samples_per_line + ctx->samples_per_line / 2; outsize = length_in / ctx->unitsize * ctx->num_enabled_probes / ctx->samples_per_line * max_linelen + 512; if (!(outbuf = g_try_malloc0(outsize + 1))) { sr_err("%s: outbuf malloc failed", __func__); return SR_ERR_MALLOC; } outbuf[0] = '\0'; if (ctx->header) { /* The header is still here, this must be the first packet. */ strncpy((char *)outbuf, ctx->header, outsize); g_free(ctx->header); ctx->header = NULL; } ctx->line_offset = 0; for (offset = 0; offset <= length_in - ctx->unitsize; offset += ctx->unitsize) { sample = data_in + offset; for (p = 0; p < ctx->num_enabled_probes; p++) { ctx->linevalues[p] <<= 1; if (sample[p / 8] & ((uint8_t) 1 << (p % 8))) ctx->linevalues[p] |= 1; sprintf((char *)ctx->linebuf + (p * ctx->linebuf_len) + ctx->line_offset, "%.2x", ctx->linevalues[p]); } ctx->spl_cnt++; /* 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) { flush_linebufs(ctx, outbuf); ctx->line_offset = ctx->spl_cnt = 0; } } *data_out = outbuf; *length_out = strlen((const char *)outbuf); return SR_OK; }