X-Git-Url: https://sigrok.org/gitweb/?p=sigrok-cli.git;a=blobdiff_plain;f=session.c;h=3d0e25182e2db4121c3de1cabaf14617680882fa;hp=6f900853be27b7d2cc99da10ed9fccf51e43a1ed;hb=6ea663a7639b87bab38c4c94624fdc9cce633ca4;hpb=c7a5cb12421c05c2ab3e54472f93531a239ca12c diff --git a/session.c b/session.c index 6f90085..3d0e251 100644 --- a/session.c +++ b/session.c @@ -21,11 +21,12 @@ #include "config.h" #include #include +#include +#include static struct sr_output_format *output_format = NULL; static int default_output_format = FALSE; static char *output_format_param = NULL; -static GByteArray *savebuf; static uint64_t limit_samples = 0; static uint64_t limit_frames = 0; @@ -43,26 +44,6 @@ extern gchar *opt_triggers; extern struct srd_session *srd_sess; #endif - -static GArray *get_enabled_logic_probes(const struct sr_dev_inst *sdi) -{ - struct sr_probe *probe; - GArray *probes; - GSList *l; - - probes = g_array_new(FALSE, FALSE, sizeof(int)); - for (l = sdi->probes; l; l = l->next) { - probe = l->data; - if (probe->type != SR_PROBE_LOGIC) - continue; - if (probe->enabled != TRUE) - continue; - g_array_append_val(probes, probe->index); - } - - return probes; -} - static int set_limit_time(const struct sr_dev_inst *sdi) { GVariant *gvar; @@ -164,17 +145,20 @@ void datafeed_in(const struct sr_dev_inst *sdi, const struct sr_datafeed_logic *logic; const struct sr_datafeed_analog *analog; struct sr_config *src; + struct sr_probe *probe; static struct sr_output *o = NULL; - static GArray *logic_probelist = NULL; - static uint64_t received_samples = 0; - static int unitsize = 0; + static uint64_t rcvd_samples_logic = 0; + static uint64_t rcvd_samples_analog = 0; + static uint64_t samplerate = 0; static int triggered = 0; static FILE *outfile = NULL; GSList *l; GString *out; - int sample_size, ret; - uint64_t samplerate, output_len, filter_out_len, end_sample; - uint8_t *output_buf, *filter_out; + uint64_t end_sample; + uint64_t output_len, input_len; + uint8_t *output_buf; + int i; + char **probes; (void) cb_data; @@ -182,7 +166,6 @@ void datafeed_in(const struct sr_dev_inst *sdi, if (packet->type != SR_DF_HEADER && o == NULL) return; - sample_size = -1; switch (packet->type) { case SR_DF_HEADER: g_debug("cli: Received SR_DF_HEADER"); @@ -205,26 +188,18 @@ void datafeed_in(const struct sr_dev_inst *sdi, outfile = stdout; if (opt_output_file) { if (default_output_format) { - /* output file is in session format, so we'll - * keep a copy of everything as it comes in - * and save from there after the session. */ outfile = NULL; - savebuf = g_byte_array_new(); } else { /* saving to a file in whatever format was set * with --format, so all we need is a filehandle */ outfile = g_fopen(opt_output_file, "wb"); } } - - /* Prepare for logic data. */ - logic_probelist = get_enabled_logic_probes(sdi); - /* How many bytes we need to store the packed samples. */ - unitsize = (logic_probelist->len + 7) / 8; + rcvd_samples_logic = rcvd_samples_analog = 0; #ifdef HAVE_SRD - GVariant *gvar; - if (opt_pds && logic_probelist->len) { + if (opt_pds) { + GVariant *gvar; if (sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE, &gvar) == SR_OK) { samplerate = g_variant_get_uint64(gvar); @@ -283,7 +258,6 @@ void datafeed_in(const struct sr_dev_inst *sdi, case SR_DF_LOGIC: logic = packet->payload; g_message("cli: received SR_DF_LOGIC, %"PRIu64" bytes", logic->length); - sample_size = logic->unitsize; if (logic->length == 0) break; @@ -291,40 +265,42 @@ void datafeed_in(const struct sr_dev_inst *sdi, if (opt_wait_trigger && !triggered) break; - if (limit_samples && received_samples >= limit_samples) + if (limit_samples && rcvd_samples_logic >= limit_samples) break; - ret = sr_filter_probes(sample_size, unitsize, logic_probelist, - logic->data, logic->length, - &filter_out, &filter_out_len); - if (ret != SR_OK) - break; - - /* - * What comes out of the filter is guaranteed to be packed into the - * minimum size needed to support the number of samples at this sample - * size. however, the driver may have submitted too much. Cut off - * the buffer of the last packet according to the sample limit. - */ - if (limit_samples && (received_samples + logic->length / sample_size > - limit_samples * sample_size)) - filter_out_len = limit_samples * sample_size - received_samples; + end_sample = rcvd_samples_logic + logic->length / logic->unitsize; + /* Cut off last packet according to the sample limit. */ + if (limit_samples && end_sample > limit_samples) + end_sample = limit_samples; + input_len = (end_sample - rcvd_samples_logic) * logic->unitsize; if (opt_output_file && default_output_format) { /* Saving to a session file. */ - g_byte_array_append(savebuf, filter_out, filter_out_len); + if (rcvd_samples_logic == 0) { + /* First packet with logic data, init session file. */ + probes = g_malloc(sizeof(char *) * g_slist_length(sdi->probes)); + for (i = 0, l = sdi->probes; l; l = l->next) { + probe = l->data; + if (probe->enabled && probe->type == SR_PROBE_LOGIC) + probes[i++] = probe->name; + } + probes[i] = NULL; + sr_session_save_init(opt_output_file, samplerate, + probes); + g_free(probes); + } + save_chunk_logic(logic->data, input_len, logic->unitsize); } else { if (opt_pds) { #ifdef HAVE_SRD - end_sample = received_samples + filter_out_len / unitsize; - if (srd_session_send(srd_sess, received_samples, end_sample, - (uint8_t*)filter_out, filter_out_len) != SRD_OK) + if (srd_session_send(srd_sess, rcvd_samples_logic, end_sample, + logic->data, input_len) != SRD_OK) sr_session_stop(); #endif } else { output_len = 0; if (o->format->data && packet->type == o->format->df_type) - o->format->data(o, filter_out, filter_out_len, + o->format->data(o, logic->data, input_len, &output_buf, &output_len); if (output_len) { fwrite(output_buf, 1, output_len, outfile); @@ -333,9 +309,8 @@ void datafeed_in(const struct sr_dev_inst *sdi, } } } - g_free(filter_out); - received_samples += logic->length / sample_size; + rcvd_samples_logic = end_sample; break; case SR_DF_ANALOG: @@ -344,7 +319,7 @@ void datafeed_in(const struct sr_dev_inst *sdi, if (analog->num_samples == 0) break; - if (limit_samples && received_samples >= limit_samples) + if (limit_samples && rcvd_samples_analog >= limit_samples) break; if (o->format->data && packet->type == o->format->df_type) { @@ -358,7 +333,7 @@ void datafeed_in(const struct sr_dev_inst *sdi, } } - received_samples += analog->num_samples; + rcvd_samples_analog += analog->num_samples; break; case SR_DF_FRAME_BEGIN: @@ -400,7 +375,7 @@ void datafeed_in(const struct sr_dev_inst *sdi, } /* SR_DF_END needs to be handled after the output module's receive() - * is called, so it can properly clean up that module etc. */ + * is called, so it can properly clean up that module. */ if (packet->type == SR_DF_END) { g_debug("cli: Received SR_DF_END"); @@ -414,16 +389,6 @@ void datafeed_in(const struct sr_dev_inst *sdi, } } - if (limit_samples && received_samples < limit_samples) - g_warning("Device only sent %" PRIu64 " samples.", - received_samples); - - if (opt_continuous) - g_warning("Device stopped after %" PRIu64 " samples.", - received_samples); - - g_array_free(logic_probelist, TRUE); - if (o->format->cleanup) o->format->cleanup(o); g_free(o); @@ -432,11 +397,17 @@ void datafeed_in(const struct sr_dev_inst *sdi, if (outfile && outfile != stdout) fclose(outfile); - if (opt_output_file && default_output_format && savebuf->len) { - if (sr_session_save(opt_output_file, sdi, savebuf->data, - unitsize, savebuf->len / unitsize) != SR_OK) - g_critical("Failed to save session."); - g_byte_array_free(savebuf, TRUE); + if (opt_output_file && default_output_format) + /* Flush whatever is left out to the session file. */ + save_chunk_logic(NULL, 0, 0); + + if (limit_samples) { + if (rcvd_samples_logic > 0 && rcvd_samples_logic < limit_samples) + g_warning("Device only sent %" PRIu64 " samples.", + rcvd_samples_logic); + else if (rcvd_samples_analog > 0 && rcvd_samples_analog < limit_samples) + g_warning("Device only sent %" PRIu64 " samples.", + rcvd_samples_analog); } } @@ -551,7 +522,7 @@ void run_session(void) GHashTable *devargs; GVariant *gvar; struct sr_dev_inst *sdi; - uint64_t max_samples; + uint64_t min_samples, max_samples; int max_probes, i; char **triggerlist; @@ -630,11 +601,16 @@ void run_session(void) sr_session_destroy(); return; } - if (sr_config_get(sdi->driver, sdi, NULL, - SR_CONF_MAX_UNCOMPRESSED_SAMPLES, &gvar) == SR_OK) { + if (sr_config_list(sdi->driver, sdi, NULL, + SR_CONF_LIMIT_SAMPLES, &gvar) == SR_OK) { /* The device has no compression, or compression is turned * off, and publishes its sample memory size. */ - max_samples = g_variant_get_uint64(gvar); + g_variant_get(gvar, "(tt)", &min_samples, &max_samples); + g_variant_unref(gvar); + if (limit_samples < min_samples) { + g_critical("The device stores at least %"PRIu64 + " samples with the current settings.", min_samples); + } if (limit_samples > max_samples) { g_critical("The device can store only %"PRIu64 " samples with the current settings.", max_samples); @@ -682,3 +658,32 @@ void run_session(void) } +void save_chunk_logic(uint8_t *data, uint64_t data_len, int unitsize) +{ + static uint8_t *buf = NULL; + static int buf_len = 0; + static int last_unitsize = 0; + int max; + + if (!buf) + buf = g_malloc(SAVE_CHUNK_SIZE); + + if (buf_len + data_len > SAVE_CHUNK_SIZE) { + max = (SAVE_CHUNK_SIZE - buf_len) / unitsize * unitsize; + memcpy(buf + buf_len, data, max); + sr_session_append(opt_output_file, buf, unitsize, + (buf_len + max) / unitsize); + memcpy(buf, data + max, data_len - max); + buf_len = data_len - max; + } else if (data_len == 0) { + /* End of data, flush the buffer out. */ + sr_session_append(opt_output_file, buf, last_unitsize, + buf_len / last_unitsize); + } else { + /* Buffer chunk. */ + memcpy(buf + buf_len, data, data_len); + buf_len += data_len; + } + last_unitsize = unitsize; + +}