X-Git-Url: https://sigrok.org/gitweb/?p=sigrok-cli.git;a=blobdiff_plain;f=decode.c;h=4ddf34afbbaf00db414a041f4ef2e61ddc27bc0f;hp=adbe73b32e90a80209f7a3f31a1248a23d971f9b;hb=HEAD;hpb=c5e0e72ee3bcc799d1510c9fb91b3a0073766b2a diff --git a/decode.c b/decode.c index adbe73b..12083a1 100644 --- a/decode.c +++ b/decode.c @@ -29,8 +29,14 @@ static GHashTable *pd_meta_visible = NULL; static GHashTable *pd_binary_visible = NULL; static GHashTable *pd_channel_maps = NULL; +uint64_t pd_samplerate = 0; + extern struct srd_session *srd_sess; +static const char *keyword_assign = "assign_channels"; +static const char *assign_by_index = "auto_index"; +static const char *assign_by_name = "auto_names"; + static int opts_to_gvar(struct srd_decoder *dec, GHashTable *hash, GHashTable **options) { @@ -38,6 +44,7 @@ static int opts_to_gvar(struct srd_decoder *dec, GHashTable *hash, GSList *optl; GVariant *gvar; gint64 val_int; + double val_dbl; int ret; char *val_str, *conv; @@ -53,14 +60,25 @@ static int opts_to_gvar(struct srd_decoder *dec, GHashTable *hash, if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_STRING)) { gvar = g_variant_new_string(val_str); } else if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_INT64)) { + conv = NULL; val_int = strtoll(val_str, &conv, 0); - if (!conv || conv == val_str) { + if (!conv || conv == val_str || *conv) { g_critical("Protocol decoder '%s' option '%s' " "requires a number.", dec->name, o->id); ret = FALSE; break; } gvar = g_variant_new_int64(val_int); + } else if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_DOUBLE)) { + conv = NULL; + val_dbl = strtod(val_str, &conv); + if (!conv || conv == val_str || *conv) { + g_critical("Protocol decoder '%s' option '%s' requires a float number.", + dec->name, o->id); + ret = FALSE; + break; + } + gvar = g_variant_new_double(val_dbl); } else { g_critical("Unsupported type for option '%s' (%s)", o->id, g_variant_get_type_string(o->def)); @@ -75,7 +93,7 @@ static int opts_to_gvar(struct srd_decoder *dec, GHashTable *hash, return ret; } -static int move_hash_element(GHashTable *src, GHashTable *dest, void *key) +static int move_hash_element(GHashTable *src, GHashTable *dest, const void *key) { void *orig_key, *value; @@ -97,6 +115,7 @@ static GHashTable *extract_channel_map(struct srd_decoder *dec, GHashTable *hash channel_map = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); + move_hash_element(hash, channel_map, keyword_assign); for (l = dec->channels; l; l = l->next) { pdch = l->data; move_hash_element(hash, channel_map, pdch->id); @@ -125,7 +144,7 @@ static int register_pd(char *opt_pds, char *opt_pd_annotations) pdtokens = g_strsplit(opt_pds, ",", 0); for (pdtok = pdtokens; *pdtok; pdtok++) { - if (!(pd_opthash = parse_generic_arg(*pdtok, TRUE))) { + if (!(pd_opthash = parse_generic_arg(*pdtok, TRUE, NULL))) { g_critical("Invalid protocol decoder option '%s'.", *pdtok); break; } @@ -179,7 +198,7 @@ static int register_pd(char *opt_pds, char *opt_pd_annotations) * in the stack. */ if (!opt_pd_annotations) { - g_hash_table_insert(pd_ann_visible, g_strdup(di->inst_id), + g_hash_table_insert(pd_ann_visible, g_strdup(di->decoder->id), g_slist_append(NULL, GINT_TO_POINTER(-1))); } if (di_prior) { @@ -239,11 +258,21 @@ static void map_pd_inst_channels(void *key, void *value, void *user_data) GHashTable *channel_indices; GSList *channel_list; struct srd_decoder_inst *di; + struct srd_decoder *pd; GVariant *var; void *channel_id; void *channel_target; struct sr_channel *ch; GHashTableIter iter; + enum assign_t { + ASSIGN_UNKNOWN, + ASSIGN_USER_SPEC, + ASSIGN_BY_INDEX, + ASSIGN_BY_NAMES, + } assign; + const char *keyword; + GSList *l_pd, *l_pdo, *l_ch; + struct srd_channel *pdch; channel_map = value; channel_list = user_data; @@ -257,9 +286,108 @@ static void map_pd_inst_channels(void *key, void *value, void *user_data) channel_indices = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)g_variant_unref); + /* + * The typical mode of operation is to apply a user specified + * mapping of sigrok channels to decoder inputs. Lack of mapping + * specs will assign no signals (compatible behaviour to earlier + * implementations). + * + * Alternatively we can assign sigrok logic channels to decoder + * inputs in the strict order of channel indices, or when their + * names match. Users need to request this automatic assignment + * though, because this behaviour differs from earlier versions. + * + * Even more sophisticated heuristics of mapping sigrok channels + * to decoder inputs are not implemented here. Later versions + * could translate the Pulseview approach to the C language, but + * it's better to stabilize that logic first before porting it. + */ + assign = ASSIGN_USER_SPEC; + keyword = g_hash_table_lookup(channel_map, keyword_assign); + if (g_hash_table_size(channel_map) != 1) { + assign = ASSIGN_USER_SPEC; + } else if (!keyword) { + assign = ASSIGN_USER_SPEC; + } else if (strcmp(keyword, assign_by_index) == 0) { + assign = ASSIGN_BY_INDEX; + } else if (strcmp(keyword, assign_by_name) == 0) { + assign = ASSIGN_BY_NAMES; + } else { + g_critical("Unknown type of decoder channel assignment: %s.", + keyword); + return; + } + + pd = di->decoder; + if (assign == ASSIGN_BY_INDEX) { + /* + * Iterate the protocol decoder's list of input signals + * (mandatory and optional, never more than the decoder's + * total channels count). Assign sigrok logic channels + * until either is exhausted. Use sigrok channels in the + * very order of their declaration in the input stream. + */ + l_ch = channel_list; + l_pd = pd->channels; + while (l_ch && l_pd) { + ch = l_ch->data; + l_ch = l_ch->next; + if (ch->type != SR_CHANNEL_LOGIC) + break; + if (ch->index >= di->dec_num_channels) + break; + pdch = l_pd->data; + l_pd = l_pd->next; + if (!l_pd) + l_pd = pd->opt_channels; + /* TODO Emit an INFO message. */ + g_hash_table_insert(channel_map, + g_strdup(pdch->id), g_strdup(ch->name)); + } + } else if (assign == ASSIGN_BY_NAMES) { + /* + * Iterate the protocol decoder's list of input signals. + * Search for sigrok logic channels that have matching + * names (case insensitive comparison). Not finding a + * sigrok channel of a given name is non-fatal (could be + * an optional channel, the decoder will check later for + * all mandatory channels to be assigned). + */ + l_pd = pd->channels; + l_pdo = pd->opt_channels; + while (l_pd) { + pdch = l_pd->data; + l_pd = l_pd->next; + if (!l_pd) { + l_pd = l_pdo; + l_pdo = NULL; + } + ch = find_channel(channel_list, pdch->id, FALSE); + if (!ch) { + /* TODO Emit a WARN message. */ + /* if (l_pdo) ...; */ + continue; + } + if (ch->type != SR_CHANNEL_LOGIC) { + /* TODO Emit a WARN message. */ + continue; + } + /* TODO Emit an INFO message. */ + g_hash_table_insert(channel_map, + g_strdup(pdch->id), g_strdup(ch->name)); + } + } + g_hash_table_iter_init(&iter, channel_map); while (g_hash_table_iter_next(&iter, &channel_id, &channel_target)) { - ch = find_channel(channel_list, channel_target); + if (strcmp(channel_id, keyword_assign) == 0) + continue; + if (!channel_target) { + g_printerr("cli: Channel name for \"%s\" missing.\n", + (char *)channel_id); + continue; + } + ch = find_channel(channel_list, channel_target, TRUE); if (!ch) { g_printerr("cli: No channel with name \"%s\" found.\n", (char *)channel_target); @@ -298,46 +426,91 @@ int setup_pd_annotations(char *opt_pd_annotations) struct srd_decoder *dec; int ann_class; char **pds, **pdtok, **keyval, **annlist, **ann, **ann_descr; + const char *dec_id; + const char *ann_txt; + const char *ann_id; + const struct srd_decoder_annotation_row *row_desc; + char **ann_diag; /* Set up custom list of PDs and annotations to show. */ pds = g_strsplit(opt_pd_annotations, ",", 0); for (pdtok = pds; *pdtok && **pdtok; pdtok++) { keyval = g_strsplit(*pdtok, "=", 0); - if (!(dec = srd_decoder_get_by_id(keyval[0]))) { - g_critical("Protocol decoder '%s' not found.", keyval[0]); + dec_id = keyval[0]; + if (!(dec = srd_decoder_get_by_id(dec_id))) { + g_critical("Protocol decoder '%s' not found.", dec_id); + g_strfreev(keyval); + g_strfreev(pds); return 1; } if (!dec->annotations) { - g_critical("Protocol decoder '%s' has no annotations.", keyval[0]); + g_critical("Protocol decoder '%s' has no annotations.", dec_id); + g_strfreev(keyval); + g_strfreev(pds); return 1; } - if (g_strv_length(keyval) == 2 && keyval[1][0] != '\0') { - annlist = g_strsplit(keyval[1], ":", 0); + ann_txt = (g_strv_length(keyval) == 2) ? keyval[1] : NULL; + if (ann_txt && *ann_txt) { + annlist = g_strsplit(ann_txt, ":", 0); for (ann = annlist; *ann && **ann; ann++) { + ann_id = *ann; + g_debug("cli: Lookup decoder %s annotation %s.", dec_id, ann_id); + /* Lookup annotation class. */ ann_class = 0; for (l = dec->annotations; l; l = l->next, ann_class++) { ann_descr = l->data; - if (!canon_cmp(ann_descr[0], *ann)) + if (!canon_cmp(ann_descr[0], ann_id)) /* Found it. */ break; } - if (!l) { - g_critical("Annotation '%s' not found " - "for protocol decoder '%s'.", *ann, keyval[0]); - return 1; + if (l) { + l_ann = g_hash_table_lookup(pd_ann_visible, dec_id); + l_ann = g_slist_append(l_ann, GINT_TO_POINTER(ann_class)); + g_hash_table_replace(pd_ann_visible, g_strdup(dec_id), l_ann); + g_debug("cli: Showing protocol decoder %s annotation " + "class %d (%s).", dec_id, ann_class, ann_descr[0]); + continue; + } + /* Lookup annotation row. */ + for (l = dec->annotation_rows; l; l = l->next) { + row_desc = l->data; + if (!canon_cmp(row_desc->id, ann_id)) + break; } - l_ann = g_hash_table_lookup(pd_ann_visible, keyval[0]); - l_ann = g_slist_append(l_ann, GINT_TO_POINTER(ann_class)); - g_hash_table_replace(pd_ann_visible, g_strdup(keyval[0]), l_ann); - g_debug("cli: Showing protocol decoder %s annotation " - "class %d (%s).", keyval[0], ann_class, ann_descr[0]); + if (l) { + g_debug("cli: Showing decoder %s annotation row %s (%s).", + dec_id, row_desc->id, row_desc->desc); + l_ann = g_hash_table_lookup(pd_ann_visible, dec_id); + for (l = row_desc->ann_classes; l; l = l->next) { + /* + * This could just be: + * l_ann = g_slist_append(l_ann, l->data); + * But we are explicit for readability + * and to access details for diagnostics. + */ + ann_class = GPOINTER_TO_INT(l->data); + l_ann = g_slist_append(l_ann, GINT_TO_POINTER(ann_class)); + ann_diag = g_slist_nth_data(dec->annotations, ann_class); + g_debug("cli: Adding class %d/%s from row %s.", + ann_class, ann_diag[0], row_desc->id); + } + g_hash_table_replace(pd_ann_visible, g_strdup(dec_id), l_ann); + continue; + } + /* No match found. */ + g_critical("Annotation '%s' not found " + "for protocol decoder '%s'.", ann_id, dec_id); + g_strfreev(keyval); + g_strfreev(pds); + return 1; } } else { /* No class specified: show all of them. */ - g_hash_table_insert(pd_ann_visible, g_strdup(keyval[0]), - g_slist_append(NULL, GINT_TO_POINTER(-1))); + ann_class = -1; + l_ann = g_slist_append(NULL, GINT_TO_POINTER(ann_class)); + g_hash_table_insert(pd_ann_visible, g_strdup(dec_id), l_ann); g_debug("cli: Showing all annotation classes for protocol " - "decoder %s.", keyval[0]); + "decoder %s.", dec_id); } g_strfreev(keyval); } @@ -416,6 +589,147 @@ int setup_pd_binary(char *opt_pd_binary) return 0; } +/* + * Balance JSON object and array parentheses, and separate array items. + * Somewhat convoluted API to re-use the routine for individual items as + * well as the surrounding array and object, including deferred start of + * the output and late flush (and to keep the state strictly local to the + * routine). Some additional complexity due to JSON's inability to handle + * a trailing comma at the last item. Code phrased such that text literals + * are kept in their order of appearance in the output (where possible). + */ +static void jsontrace_open_close(gboolean is_close_req, + gboolean open_item, gboolean close_item) +{ + static gboolean is_file_open; + static gboolean is_item_open; + + if (is_close_req && is_item_open) + close_item = TRUE; + + /* Automatic file header, and array item separation. */ + if (open_item) { + if (!is_file_open) + printf("{\"traceEvents\": [\n"); + if (is_item_open) { + printf("}"); + is_item_open = FALSE; + } + if (is_file_open) { + printf(",\n"); + } + is_file_open = TRUE; + } + + /* Array item open/append/close. */ + if (open_item) { + printf("{"); + is_item_open = TRUE; + } + if (!open_item && !close_item && !is_close_req) { + printf(", "); + is_item_open = TRUE; + } + if (close_item) { + printf("}"); + is_item_open = FALSE; + } + + /* Automatic file footer on shutdown. */ + if (is_close_req && is_file_open) { + printf("\n"); + printf("]}\n"); + } + if (is_close_req) + is_file_open = FALSE; + + /* Flush at end of lines, or end of file. */ + if (close_item || is_close_req) + fflush(stdout); +} + +/* Convert uint64 sample number to double timestamp in microseconds. */ +static double jsontrace_ts_usec(uint64_t snum) +{ + double ts_usec; + + ts_usec = snum; + ts_usec *= 1e6; + ts_usec /= pd_samplerate; + return ts_usec; +} + +/* Emit two Google Trace Events (JSON) for one PD annotation (ss, es). */ +static void jsontrace_annotation(struct srd_decoder *dec, + struct srd_proto_data_annotation *pda, struct srd_proto_data *pdata) +{ + char *row_text; + GSList *lrow, *lcls; + struct srd_decoder_annotation_row *row; + int cls; + char **ann_descr; + + /* + * Search for an annotation row for this index, or use the + * annotation's descriptor. + */ + row_text = NULL; + if (dec->annotation_rows) { + for (lrow = dec->annotation_rows; lrow; lrow = lrow->next) { + row = lrow->data; + for (lcls = row->ann_classes; lcls; lcls = lcls->next) { + cls = GPOINTER_TO_INT(lcls->data); + if (cls == pda->ann_class) { + row_text = row->desc; + break; + } + } + if (row_text) + break; + } + } + if (!row_text) { + ann_descr = g_slist_nth_data(dec->annotations, pda->ann_class); + row_text = ann_descr[0]; + } + + /* + * Emit two Google Trace Events for the start and end times. + * Set the 'pid' (process ID) to the decoder name to group a + * decoder's annotations. Set the 'tid' (thread ID) to the + * annotation row's description. The 'ts' (timestamp) is in + * microseconds. Set 'name' to the longest annotation text. + * + * BEWARE of the unfortunate JSON format limitation, which + * clutters data output calls with format helper calls. + * TODO Want to introduce a cJSON dependency to delegate the + * construction of output text? + */ + jsontrace_open_close(FALSE, TRUE, FALSE); + printf("\"%s\": \"%s\"", "ph", "B"); + jsontrace_open_close(FALSE, FALSE, FALSE); + printf("\"%s\": %lf", "ts", jsontrace_ts_usec(pdata->start_sample)); + jsontrace_open_close(FALSE, FALSE, FALSE); + printf("\"%s\": \"%s\"", "pid", pdata->pdo->proto_id); + jsontrace_open_close(FALSE, FALSE, FALSE); + printf("\"%s\": \"%s\"", "tid", row_text); + jsontrace_open_close(FALSE, FALSE, FALSE); + printf("\"%s\": \"%s\"", "name", pda->ann_text[0]); + + jsontrace_open_close(FALSE, TRUE, FALSE); + printf("\"%s\": \"%s\"", "ph", "E"); + jsontrace_open_close(FALSE, FALSE, FALSE); + printf("\"%s\": %lf", "ts", jsontrace_ts_usec(pdata->end_sample)); + jsontrace_open_close(FALSE, FALSE, FALSE); + printf("\"%s\": \"%s\"", "pid", pdata->pdo->proto_id); + jsontrace_open_close(FALSE, FALSE, FALSE); + printf("\"%s\": \"%s\"", "tid", row_text); + jsontrace_open_close(FALSE, FALSE, FALSE); + printf("\"%s\": \"%s\"", "name", pda->ann_text[0]); + + jsontrace_open_close(FALSE, FALSE, TRUE); +} + void show_pd_annotations(struct srd_proto_data *pdata, void *cb_data) { struct srd_decoder *dec; @@ -423,47 +737,83 @@ void show_pd_annotations(struct srd_proto_data *pdata, void *cb_data) GSList *ann_list, *l; int i; char **ann_descr; - gboolean show; + gboolean show_ann, show_snum, show_class, show_quotes, show_abbrev; + const char *quote; (void)cb_data; if (!pd_ann_visible) return; - if (!g_hash_table_lookup_extended(pd_ann_visible, pdata->pdo->di->inst_id, - NULL, (void **)&ann_list)) + if (!g_hash_table_lookup_extended(pd_ann_visible, pdata->pdo->di->decoder->id, + NULL, (void **)&ann_list)) { /* Not in the list of PDs whose annotations we're showing. */ return; + } dec = pdata->pdo->di->decoder; pda = pdata->data; - show = FALSE; + show_ann = FALSE; for (l = ann_list; l; l = l->next) { if (GPOINTER_TO_INT(l->data) == -1 || GPOINTER_TO_INT(l->data) == pda->ann_class) { - show = TRUE; + show_ann = TRUE; break; } } - if (!show) + if (!show_ann) return; - if (opt_loglevel <= SR_LOG_WARN) { - /* Show only the longest annotation. */ - printf("%s: %s", pdata->pdo->proto_id, pda->ann_text[0]); - } else if (opt_loglevel >= SR_LOG_INFO) { - /* Sample numbers and quotes around the longest annotation. */ - printf("%"PRIu64"-%"PRIu64"", pdata->start_sample, pdata->end_sample); - if (opt_loglevel == SR_LOG_INFO) { - printf(" %s \"%s\"", pdata->pdo->proto_id, pda->ann_text[0]); - } else { - /* Protocol decoder id, annotation class, - * all annotation strings. */ - ann_descr = g_slist_nth_data(dec->annotations, pda->ann_class); - printf(" %s: %s:", pdata->pdo->proto_id, ann_descr[0]); - for (i = 0; pda->ann_text[i]; i++) - printf(" \"%s\"", pda->ann_text[i]); - } + /* Google Trace Events are rather special. Use a separate code path. */ + if (opt_pd_jsontrace) { + jsontrace_annotation(dec, pda, pdata); + return; + } + + /* + * Determine which fields of the annotation to display. Inspect + * user specified options as well as the verbosity of the log level: + * - Optionally show the sample numbers for the annotation's span. + * - Always show the protocol decoder ID. + * - Optionally show the annotation's class description. + * - Always show the longest annotation text. + * - Optionally show alternative annotation text (abbreviations + * for different zoom levels). + * - Optionally put quote marks around annotation text, when + * recipients might have to deal with a set of text variants. + */ + show_snum = show_class = show_quotes = show_abbrev = FALSE; + if (opt_pd_samplenum || opt_loglevel > SR_LOG_WARN) { + show_snum = TRUE; + } + if (opt_loglevel > SR_LOG_WARN) { + show_quotes = TRUE; + } + if (opt_loglevel > SR_LOG_INFO) { + show_class = TRUE; + show_abbrev = TRUE; + } + if (opt_pd_ann_class) + show_class = TRUE; + + /* + * Display the annotation's fields after the layout was + * determined above. + */ + if (show_snum) { + printf("%" PRIu64 "-%" PRIu64 " ", + pdata->start_sample, pdata->end_sample); + } + printf("%s: ", pdata->pdo->proto_id); + if (show_class) { + ann_descr = g_slist_nth_data(dec->annotations, pda->ann_class); + printf("%s: ", ann_descr[0]); + } + quote = show_quotes ? "\"" : ""; + printf("%s%s%s", quote, pda->ann_text[0], quote); + if (show_abbrev) { + for (i = 1; pda->ann_text[i]; i++) + printf(" %s%s%s", quote, pda->ann_text[i], quote); } printf("\n"); fflush(stdout); @@ -478,7 +828,7 @@ void show_pd_meta(struct srd_proto_data *pdata, void *cb_data) /* Not in the list of PDs whose meta output we're showing. */ return; - if (opt_loglevel > SR_LOG_WARN) + if (opt_pd_samplenum || opt_loglevel > SR_LOG_WARN) printf("%"PRIu64"-%"PRIu64" ", pdata->start_sample, pdata->end_sample); printf("%s: ", pdata->pdo->proto_id); printf("%s: %s", pdata->pdo->meta_name, g_variant_print(pdata->data, FALSE)); @@ -490,7 +840,7 @@ void show_pd_binary(struct srd_proto_data *pdata, void *cb_data) { struct srd_proto_data_binary *pdb; gpointer classp; - int class; + int classi; (void)cb_data; @@ -499,9 +849,9 @@ void show_pd_binary(struct srd_proto_data *pdata, void *cb_data) /* Not in the list of PDs whose meta output we're showing. */ return; - class = GPOINTER_TO_INT(classp); + classi = GPOINTER_TO_INT(classp); pdb = pdata->data; - if (class != -1 && class != pdb->bin_class) + if (classi != -1 && classi != pdb->bin_class) /* Not showing this binary class. */ return; @@ -509,4 +859,16 @@ void show_pd_binary(struct srd_proto_data *pdata, void *cb_data) fwrite(pdb->data, pdb->size, 1, stdout); fflush(stdout); } + +void show_pd_prepare(void) +{ + if (opt_pd_jsontrace) + jsontrace_open_close(TRUE, FALSE, FALSE); +} + +void show_pd_close(void) +{ + if (opt_pd_jsontrace) + jsontrace_open_close(TRUE, FALSE, FALSE); +} #endif