2 * This file is part of the sigrok project.
4 * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include <sigrokdecode.h> /* First, so we avoid a _POSIX_C_SOURCE warning. */
31 #include <sys/types.h>
35 #include <glib/gstdio.h>
36 #include <libsigrok/libsigrok.h>
37 #include "sigrok-cli.h"
39 #define DEFAULT_OUTPUT_FORMAT "bits:width=64"
41 static struct sr_context
*sr_ctx
= NULL
;
43 static uint64_t limit_samples
= 0;
44 static uint64_t limit_frames
= 0;
45 static struct sr_output_format
*output_format
= NULL
;
46 static int default_output_format
= FALSE
;
47 static char *output_format_param
= NULL
;
49 static GHashTable
*pd_ann_visible
= NULL
;
51 static GByteArray
*savebuf
;
53 static gboolean opt_version
= FALSE
;
54 static gint opt_loglevel
= SR_LOG_WARN
; /* Show errors+warnings per default. */
55 static gboolean opt_list_devs
= FALSE
;
56 static gboolean opt_wait_trigger
= FALSE
;
57 static gchar
*opt_input_file
= NULL
;
58 static gchar
*opt_output_file
= NULL
;
59 static gchar
*opt_drv
= NULL
;
60 static gchar
*opt_dev
= NULL
;
61 static gchar
*opt_probes
= NULL
;
62 static gchar
*opt_triggers
= NULL
;
63 static gchar
*opt_pds
= NULL
;
65 static gchar
*opt_pd_stack
= NULL
;
66 static gchar
*opt_pd_annotations
= NULL
;
68 static gchar
*opt_input_format
= NULL
;
69 static gchar
*opt_output_format
= NULL
;
70 static gchar
*opt_show
= NULL
;
71 static gchar
*opt_time
= NULL
;
72 static gchar
*opt_samples
= NULL
;
73 static gchar
*opt_frames
= NULL
;
74 static gchar
*opt_continuous
= NULL
;
75 static gchar
*opt_set
= NULL
;
77 static GOptionEntry optargs
[] = {
78 {"version", 'V', 0, G_OPTION_ARG_NONE
, &opt_version
,
79 "Show version and support list", NULL
},
80 {"loglevel", 'l', 0, G_OPTION_ARG_INT
, &opt_loglevel
,
81 "Set libsigrok/libsigrokdecode loglevel", NULL
},
82 {"list-devices", 'D', 0, G_OPTION_ARG_NONE
, &opt_list_devs
,
83 "Scan for devices", NULL
},
84 {"driver", 0, 0, G_OPTION_ARG_STRING
, &opt_drv
,
85 "Use only this driver", NULL
},
86 {"device", 'd', 0, G_OPTION_ARG_STRING
, &opt_dev
,
87 "Use specified device", NULL
},
88 {"input-file", 'i', 0, G_OPTION_ARG_FILENAME
, &opt_input_file
,
89 "Load input from file", NULL
},
90 {"input-format", 'I', 0, G_OPTION_ARG_STRING
, &opt_input_format
,
91 "Input format", NULL
},
92 {"output-file", 'o', 0, G_OPTION_ARG_FILENAME
, &opt_output_file
,
93 "Save output to file", NULL
},
94 {"output-format", 'O', 0, G_OPTION_ARG_STRING
, &opt_output_format
,
95 "Output format", NULL
},
96 {"probes", 'p', 0, G_OPTION_ARG_STRING
, &opt_probes
,
97 "Probes to use", NULL
},
98 {"triggers", 't', 0, G_OPTION_ARG_STRING
, &opt_triggers
,
99 "Trigger configuration", NULL
},
100 {"wait-trigger", 'w', 0, G_OPTION_ARG_NONE
, &opt_wait_trigger
,
101 "Wait for trigger", NULL
},
103 {"protocol-decoders", 'a', 0, G_OPTION_ARG_STRING
, &opt_pds
,
104 "Protocol decoders to run", NULL
},
105 {"protocol-decoder-stack", 's', 0, G_OPTION_ARG_STRING
, &opt_pd_stack
,
106 "Protocol decoder stack", NULL
},
107 {"protocol-decoder-annotations", 'A', 0, G_OPTION_ARG_STRING
, &opt_pd_annotations
,
108 "Protocol decoder annotation(s) to show", NULL
},
110 {"show", 0, 0, G_OPTION_ARG_NONE
, &opt_show
,
111 "Show device detail", NULL
},
112 {"time", 0, 0, G_OPTION_ARG_STRING
, &opt_time
,
113 "How long to sample (ms)", NULL
},
114 {"samples", 0, 0, G_OPTION_ARG_STRING
, &opt_samples
,
115 "Number of samples to acquire", NULL
},
116 {"frames", 0, 0, G_OPTION_ARG_STRING
, &opt_frames
,
117 "Number of frames to acquire", NULL
},
118 {"continuous", 0, 0, G_OPTION_ARG_NONE
, &opt_continuous
,
119 "Sample continuously", NULL
},
120 {"set", 0, 0, G_OPTION_ARG_NONE
, &opt_set
, "Set device options only", NULL
},
121 {NULL
, 0, 0, 0, NULL
, NULL
, NULL
}
125 /* Convert driver options hash to GSList of struct sr_config. */
126 static GSList
*hash_to_hwopt(GHashTable
*hash
)
128 const struct sr_config_info
*srci
;
129 struct sr_config
*src
;
134 keys
= g_hash_table_get_keys(hash
);
136 for (gl
= keys
; gl
; gl
= gl
->next
) {
138 if (!(srci
= sr_config_info_name_get(key
))) {
139 g_critical("Unknown option %s", key
);
142 src
= g_try_malloc(sizeof(struct sr_config
));
143 src
->key
= srci
->key
;
144 value
= g_hash_table_lookup(hash
, key
);
145 src
->data
= g_variant_new_string(value
);
146 opts
= g_slist_append(opts
, src
);
153 static void free_drvopts(struct sr_config
*src
)
155 g_variant_unref(src
->data
);
159 static GSList
*device_scan(void)
161 struct sr_dev_driver
**drivers
, *driver
;
163 GSList
*drvopts
, *devices
, *tmpdevs
, *l
;
168 drvargs
= parse_generic_arg(opt_drv
, TRUE
);
169 drvname
= g_strdup(g_hash_table_lookup(drvargs
, "sigrok_key"));
170 g_hash_table_remove(drvargs
, "sigrok_key");
172 drivers
= sr_driver_list();
173 for (i
= 0; drivers
[i
]; i
++) {
174 if (strcmp(drivers
[i
]->name
, drvname
))
179 g_critical("Driver %s not found.", drvname
);
183 if (sr_driver_init(sr_ctx
, driver
) != SR_OK
) {
184 g_critical("Failed to initialize driver.");
188 if (g_hash_table_size(drvargs
) > 0)
189 if (!(drvopts
= hash_to_hwopt(drvargs
)))
190 /* Unknown options, already logged. */
192 devices
= sr_driver_scan(driver
, drvopts
);
193 g_slist_free_full(drvopts
, (GDestroyNotify
)free_drvopts
);
195 /* No driver specified, let them all scan on their own. */
197 drivers
= sr_driver_list();
198 for (i
= 0; drivers
[i
]; i
++) {
200 if (sr_driver_init(sr_ctx
, driver
) != SR_OK
) {
201 g_critical("Failed to initialize driver.");
204 tmpdevs
= sr_driver_scan(driver
, NULL
);
205 for (l
= tmpdevs
; l
; l
= l
->next
)
206 devices
= g_slist_append(devices
, l
->data
);
207 g_slist_free(tmpdevs
);
214 static void show_version(void)
216 struct sr_dev_driver
**drivers
;
217 struct sr_input_format
**inputs
;
218 struct sr_output_format
**outputs
;
221 struct srd_decoder
*dec
;
225 printf("sigrok-cli %s\n\n", VERSION
);
227 printf("Using libsigrok %s (lib version %s).\n",
228 sr_package_version_string_get(), sr_lib_version_string_get());
230 printf("Using libsigrokdecode %s (lib version %s).\n\n",
231 srd_package_version_string_get(), srd_lib_version_string_get());
234 printf("Supported hardware drivers:\n");
235 drivers
= sr_driver_list();
236 for (i
= 0; drivers
[i
]; i
++) {
237 printf(" %-20s %s\n", drivers
[i
]->name
, drivers
[i
]->longname
);
241 printf("Supported input formats:\n");
242 inputs
= sr_input_list();
243 for (i
= 0; inputs
[i
]; i
++)
244 printf(" %-20s %s\n", inputs
[i
]->id
, inputs
[i
]->description
);
247 printf("Supported output formats:\n");
248 outputs
= sr_output_list();
249 for (i
= 0; outputs
[i
]; i
++)
250 printf(" %-20s %s\n", outputs
[i
]->id
, outputs
[i
]->description
);
254 if (srd_init(NULL
) == SRD_OK
) {
255 printf("Supported protocol decoders:\n");
256 srd_decoder_load_all();
257 for (l
= srd_decoder_list(); l
; l
= l
->next
) {
259 printf(" %-20s %s\n", dec
->id
, dec
->longname
);
260 /* Print protocol description upon "-l 3" or higher. */
261 if (opt_loglevel
>= SR_LOG_INFO
)
262 printf(" %-20s %s\n", "", dec
->desc
);
270 static void print_dev_line(const struct sr_dev_inst
*sdi
)
272 struct sr_probe
*probe
;
275 if (sdi
->vendor
&& sdi
->vendor
[0])
276 printf("%s ", sdi
->vendor
);
277 if (sdi
->model
&& sdi
->model
[0])
278 printf("%s ", sdi
->model
);
279 if (sdi
->version
&& sdi
->version
[0])
280 printf("%s ", sdi
->version
);
282 if (g_slist_length(sdi
->probes
) == 1) {
283 probe
= sdi
->probes
->data
;
284 printf("with 1 probe: %s", probe
->name
);
286 printf("with %d probes:", g_slist_length(sdi
->probes
));
287 for (l
= sdi
->probes
; l
; l
= l
->next
) {
289 printf(" %s", probe
->name
);
296 static void show_dev_list(void)
298 struct sr_dev_inst
*sdi
;
301 if (!(devices
= device_scan()))
304 printf("The following devices were found:\n");
305 for (l
= devices
; l
; l
= l
->next
) {
309 g_slist_free(devices
);
313 static void show_dev_detail(void)
315 struct sr_dev_inst
*sdi
;
316 const struct sr_config_info
*srci
;
318 GVariant
*gvar_opts
, *gvar_dict
, *gvar_list
, *gvar
;
319 gsize num_opts
, num_elements
;
320 const uint64_t *int64
, p
, q
;
322 unsigned int num_devices
, tmp_bool
, o
, i
;
324 const char *charopts
, **stropts
;
326 if (!(devices
= device_scan())) {
327 g_critical("No devices found.");
331 num_devices
= g_slist_length(devices
);
332 if (num_devices
> 1) {
333 g_critical("%d devices found. Use --list-devices to show them, "
334 "and --device to select one.", num_devices
);
341 /* This properly opens and initializes the device, so we can get
342 * current settings. */
344 if (sr_session_dev_add(sdi
) != SR_OK
) {
345 g_critical("Failed to use device.");
349 if ((sr_config_list(sdi
->driver
, SR_CONF_SCAN_OPTIONS
, &gvar_opts
,
351 opts
= g_variant_get_fixed_array(gvar_opts
, &num_elements
,
353 printf("Supported driver options:\n");
354 for (i
= 0; i
< num_elements
; i
++) {
355 if (!(srci
= sr_config_info_get(opts
[i
])))
357 printf(" %s\n", srci
->id
);
359 g_variant_unref(gvar_opts
);
362 if ((sr_config_list(sdi
->driver
, SR_CONF_DEVICE_OPTIONS
, &gvar_opts
,
364 /* Driver supports no device instance options. */
367 printf("Supported device options:\n");
368 opts
= g_variant_get_fixed_array(gvar_opts
, &num_opts
, sizeof(int32_t));
369 for (o
= 0; o
< num_opts
; o
++) {
370 if (!(srci
= sr_config_info_get(opts
[o
])))
373 if (srci
->key
== SR_CONF_TRIGGER_TYPE
) {
374 if (sr_config_list(sdi
->driver
, srci
->key
, &gvar
,
379 charopts
= g_variant_get_string(gvar
, NULL
);
380 printf(" Supported triggers: ");
382 printf("%c ", *charopts
);
386 g_variant_unref(gvar
);
388 } else if (srci
->key
== SR_CONF_PATTERN_MODE
) {
389 /* Pattern generator modes */
390 printf(" %s", srci
->id
);
391 if (sr_config_list(sdi
->driver
, srci
->key
, &gvar
,
393 printf(" - supported patterns:\n");
394 stropts
= g_variant_get_strv(gvar
, &num_elements
);
395 for (i
= 0; i
< num_elements
; i
++)
396 printf(" %s\n", stropts
[i
]);
397 g_variant_unref(gvar
);
402 } else if (srci
->key
== SR_CONF_SAMPLERATE
) {
403 /* Supported samplerates */
404 printf(" %s", srci
->id
);
405 if (sr_config_list(sdi
->driver
, SR_CONF_SAMPLERATE
,
406 &gvar_dict
, sdi
) != SR_OK
) {
410 if ((gvar_list
= g_variant_lookup_value(gvar_dict
,
411 "samplerates", G_VARIANT_TYPE("at")))) {
412 int64
= g_variant_get_fixed_array(gvar_list
,
413 &num_elements
, sizeof(uint64_t));
414 printf(" - supported samplerates:\n");
415 for (i
= 0; i
< num_elements
; i
++)
416 printf(" %s\n", sr_samplerate_string(int64
[i
]));
417 } if ((gvar_list
= g_variant_lookup_value(gvar_dict
,
418 "samplerate-steps", G_VARIANT_TYPE("at")))) {
419 int64
= g_variant_get_fixed_array(gvar_list
,
420 &num_elements
, sizeof(uint64_t));
422 if (!(s
= sr_samplerate_string(int64
[0])))
427 if (!(s
= sr_samplerate_string(int64
[1])))
432 if (!(s
= sr_samplerate_string(int64
[2])))
434 printf(" in steps of %s)\n", s
);
436 g_variant_unref(gvar_list
);
438 g_variant_unref(gvar_dict
);
440 } else if (srci
->key
== SR_CONF_BUFFERSIZE
) {
441 /* Supported buffer sizes */
442 printf(" %s", srci
->id
);
443 if (sr_config_list(sdi
->driver
, SR_CONF_BUFFERSIZE
,
444 &gvar_list
, sdi
) != SR_OK
) {
448 int64
= g_variant_get_fixed_array(gvar_list
,
449 &num_elements
, sizeof(uint64_t));
450 printf(" - supported buffer sizes:\n");
451 for (i
= 0; i
< num_elements
; i
++)
452 printf(" %"PRIu64
"\n", int64
[i
]);
453 g_variant_unref(gvar_list
);
455 } else if (srci
->key
== SR_CONF_TIMEBASE
) {
456 /* Supported time bases */
457 printf(" %s", srci
->id
);
458 if (sr_config_list(sdi
->driver
, SR_CONF_TIMEBASE
,
459 &gvar_list
, sdi
) != SR_OK
) {
463 printf(" - supported time bases:\n");
464 num_elements
= g_variant_n_children(gvar_list
);
465 for (i
= 0; i
< num_elements
; i
++) {
466 gvar
= g_variant_get_child_value(gvar_list
, i
);
467 g_variant_get(gvar
, "(tt)", &p
, &q
);
468 s
= sr_period_string(p
* q
);
472 g_variant_unref(gvar_list
);
474 } else if (srci
->key
== SR_CONF_TRIGGER_SOURCE
) {
475 /* Supported trigger sources */
476 printf(" %s", srci
->id
);
477 if (sr_config_list(sdi
->driver
, SR_CONF_TRIGGER_SOURCE
,
478 &gvar
, sdi
) != SR_OK
) {
482 printf(" - supported trigger sources:\n");
483 stropts
= g_variant_get_strv(gvar
, &num_elements
);
484 for (i
= 0; i
< num_elements
; i
++)
485 printf(" %s\n", stropts
[i
]);
486 g_variant_unref(gvar
);
488 } else if (srci
->key
== SR_CONF_FILTER
) {
489 /* Supported filters */
490 printf(" %s", srci
->id
);
491 if (sr_config_list(sdi
->driver
, SR_CONF_FILTER
,
492 &gvar
, sdi
) != SR_OK
) {
496 printf(" - supported filter targets:\n");
497 stropts
= g_variant_get_strv(gvar
, &num_elements
);
498 for (i
= 0; i
< num_elements
; i
++)
499 printf(" %s\n", stropts
[i
]);
500 g_variant_unref(gvar
);
502 } else if (srci
->key
== SR_CONF_VDIV
) {
503 /* Supported volts/div values */
504 printf(" %s", srci
->id
);
505 if (sr_config_list(sdi
->driver
, SR_CONF_VDIV
,
506 &gvar_list
, sdi
) != SR_OK
) {
510 printf(" - supported volts/div:\n");
511 num_elements
= g_variant_n_children(gvar_list
);
512 for (i
= 0; i
< num_elements
; i
++) {
513 gvar
= g_variant_get_child_value(gvar_list
, i
);
514 g_variant_get(gvar
, "(tt)", &p
, &q
);
515 s
= sr_voltage_string(p
, q
);
519 g_variant_unref(gvar_list
);
521 } else if (srci
->key
== SR_CONF_COUPLING
) {
522 /* Supported coupling settings */
523 printf(" %s", srci
->id
);
524 if (sr_config_list(sdi
->driver
, SR_CONF_COUPLING
,
525 &gvar
, sdi
) != SR_OK
) {
529 printf(" - supported coupling options:\n");
530 stropts
= g_variant_get_strv(gvar
, &num_elements
);
531 for (i
= 0; i
< num_elements
; i
++)
532 printf(" %s\n", stropts
[i
]);
533 g_variant_unref(gvar
);
535 } else if (srci
->key
== SR_CONF_DATALOG
) {
537 /* Turning on/off internal data logging. */
538 printf(" %s\t(on/off", srci
->id
);
539 if (sr_config_get(sdi
->driver
, SR_CONF_DATALOG
,
540 &gvar
, sdi
) == SR_OK
) {
541 tmp_bool
= g_variant_get_boolean(gvar
);
542 printf(", currently %s", tmp_bool
? "on" : "off");
543 g_variant_unref(gvar
);
547 /* Everything else */
548 printf(" %s\n", srci
->id
);
551 g_variant_unref(gvar_opts
);
553 sr_session_destroy();
558 static void show_pd_detail(void)
561 struct srd_decoder
*dec
;
562 struct srd_decoder_option
*o
;
563 char **pdtokens
, **pdtok
, *optsep
, **ann
, *val
, *doc
;
566 pdtokens
= g_strsplit(opt_pds
, ",", -1);
567 for (pdtok
= pdtokens
; *pdtok
; pdtok
++) {
569 if ((optsep
= strchr(*pdtok
, ':')))
571 if (!(dec
= srd_decoder_get_by_id(*pdtok
))) {
572 g_critical("Protocol decoder %s not found.", *pdtok
);
575 printf("ID: %s\nName: %s\nLong name: %s\nDescription: %s\n",
576 dec
->id
, dec
->name
, dec
->longname
, dec
->desc
);
577 printf("License: %s\n", dec
->license
);
578 printf("Annotations:\n");
579 if (dec
->annotations
) {
580 for (l
= dec
->annotations
; l
; l
= l
->next
) {
582 printf("- %s\n %s\n", ann
[0], ann
[1]);
587 printf("Required probes:\n");
589 for (l
= dec
->probes
; l
; l
= l
->next
) {
591 printf("- %s (%s): %s\n",
592 p
->name
, p
->id
, p
->desc
);
597 printf("Optional probes:\n");
598 if (dec
->opt_probes
) {
599 for (l
= dec
->opt_probes
; l
; l
= l
->next
) {
601 printf("- %s (%s): %s\n",
602 p
->name
, p
->id
, p
->desc
);
608 printf("Options:\n");
609 for (l
= dec
->options
; l
; l
= l
->next
) {
611 val
= g_variant_print(o
->def
, FALSE
);
612 printf("- %s: %s (default %s)\n", o
->id
, o
->desc
, val
);
616 if ((doc
= srd_decoder_doc_get(dec
))) {
617 printf("Documentation:\n%s\n",
618 doc
[0] == '\n' ? doc
+ 1 : doc
);
623 g_strfreev(pdtokens
);
627 static GArray
*get_enabled_logic_probes(const struct sr_dev_inst
*sdi
)
629 struct sr_probe
*probe
;
633 probes
= g_array_new(FALSE
, FALSE
, sizeof(int));
634 for (l
= sdi
->probes
; l
; l
= l
->next
) {
636 if (probe
->type
!= SR_PROBE_LOGIC
)
638 if (probe
->enabled
!= TRUE
)
640 g_array_append_val(probes
, probe
->index
);
646 static void datafeed_in(const struct sr_dev_inst
*sdi
,
647 const struct sr_datafeed_packet
*packet
)
649 const struct sr_datafeed_meta
*meta
;
650 const struct sr_datafeed_logic
*logic
;
651 const struct sr_datafeed_analog
*analog
;
652 struct sr_config
*src
;
653 static struct sr_output
*o
= NULL
;
654 static GArray
*logic_probelist
= NULL
;
655 static uint64_t received_samples
= 0;
656 static int unitsize
= 0;
657 static int triggered
= 0;
658 static FILE *outfile
= NULL
;
662 int sample_size
, ret
;
663 uint64_t samplerate
, output_len
, filter_out_len
;
664 uint8_t *output_buf
, *filter_out
;
666 /* If the first packet to come in isn't a header, don't even try. */
667 if (packet
->type
!= SR_DF_HEADER
&& o
== NULL
)
671 switch (packet
->type
) {
673 g_debug("cli: Received SR_DF_HEADER");
674 /* Initialize the output module. */
675 if (!(o
= g_try_malloc(sizeof(struct sr_output
)))) {
676 g_critical("Output module malloc failed.");
679 o
->format
= output_format
;
680 o
->sdi
= (struct sr_dev_inst
*)sdi
;
681 o
->param
= output_format_param
;
682 if (o
->format
->init
) {
683 if (o
->format
->init(o
) != SR_OK
) {
684 g_critical("Output format initialization failed.");
689 /* Prepare non-stdout output. */
691 if (opt_output_file
) {
692 if (default_output_format
) {
693 /* output file is in session format, so we'll
694 * keep a copy of everything as it comes in
695 * and save from there after the session. */
697 savebuf
= g_byte_array_new();
699 /* saving to a file in whatever format was set
700 * with --format, so all we need is a filehandle */
701 outfile
= g_fopen(opt_output_file
, "wb");
705 /* Prepare for logic data. */
706 logic_probelist
= get_enabled_logic_probes(sdi
);
707 /* How many bytes we need to store the packed samples. */
708 unitsize
= (logic_probelist
->len
+ 7) / 8;
711 if (opt_pds
&& logic_probelist
->len
) {
712 if (sr_config_get(sdi
->driver
, SR_CONF_SAMPLERATE
,
713 &gvar
, sdi
) != SR_OK
) {
714 g_critical("Unable to initialize protocol "
715 "decoders: no samplerate found.");
718 samplerate
= g_variant_get_uint64(gvar
);
719 g_variant_unref(gvar
);
720 srd_session_start(logic_probelist
->len
, unitsize
, samplerate
);
726 g_debug("cli: received SR_DF_META");
727 meta
= packet
->payload
;
728 for (l
= meta
->config
; l
; l
= l
->next
) {
731 case SR_CONF_SAMPLERATE
:
732 samplerate
= g_variant_get_uint64(src
->data
);
733 g_debug("cli: got samplerate %"PRIu64
" Hz", samplerate
);
735 case SR_CONF_SAMPLE_INTERVAL
:
736 samplerate
= g_variant_get_uint64(src
->data
);
737 g_debug("cli: got sample interval %"PRIu64
" ms", samplerate
);
740 /* Unknown metadata is not an error. */
747 g_debug("cli: received SR_DF_TRIGGER");
748 if (o
->format
->event
)
749 o
->format
->event(o
, SR_DF_TRIGGER
, &output_buf
,
755 logic
= packet
->payload
;
756 g_message("cli: received SR_DF_LOGIC, %"PRIu64
" bytes", logic
->length
);
757 sample_size
= logic
->unitsize
;
758 if (logic
->length
== 0)
761 /* Don't store any samples until triggered. */
762 if (opt_wait_trigger
&& !triggered
)
765 if (limit_samples
&& received_samples
>= limit_samples
)
768 ret
= sr_filter_probes(sample_size
, unitsize
, logic_probelist
,
769 logic
->data
, logic
->length
,
770 &filter_out
, &filter_out_len
);
774 /* What comes out of the filter is guaranteed to be packed into the
775 * minimum size needed to support the number of samples at this sample
776 * size. however, the driver may have submitted too much -- cut off
777 * the buffer of the last packet according to the sample limit.
779 if (limit_samples
&& (received_samples
+ logic
->length
/ sample_size
>
780 limit_samples
* sample_size
))
781 filter_out_len
= limit_samples
* sample_size
- received_samples
;
783 if (opt_output_file
&& default_output_format
) {
784 /* Saving to a session file. */
785 g_byte_array_append(savebuf
, filter_out
, filter_out_len
);
789 if (srd_session_send(received_samples
, (uint8_t*)filter_out
,
790 filter_out_len
) != SRD_OK
)
795 if (o
->format
->data
&& packet
->type
== o
->format
->df_type
)
796 o
->format
->data(o
, filter_out
, filter_out_len
,
797 &output_buf
, &output_len
);
799 fwrite(output_buf
, 1, output_len
, outfile
);
807 received_samples
+= logic
->length
/ sample_size
;
811 analog
= packet
->payload
;
812 g_message("cli: received SR_DF_ANALOG, %d samples", analog
->num_samples
);
813 if (analog
->num_samples
== 0)
816 if (limit_samples
&& received_samples
>= limit_samples
)
819 if (o
->format
->data
&& packet
->type
== o
->format
->df_type
) {
820 o
->format
->data(o
, (const uint8_t *)analog
->data
,
821 analog
->num_samples
* sizeof(float),
822 &output_buf
, &output_len
);
824 fwrite(output_buf
, 1, output_len
, outfile
);
830 received_samples
+= analog
->num_samples
;
833 case SR_DF_FRAME_BEGIN
:
834 g_debug("cli: received SR_DF_FRAME_BEGIN");
835 if (o
->format
->event
) {
836 o
->format
->event(o
, SR_DF_FRAME_BEGIN
, &output_buf
,
839 fwrite(output_buf
, 1, output_len
, outfile
);
846 case SR_DF_FRAME_END
:
847 g_debug("cli: received SR_DF_FRAME_END");
848 if (o
->format
->event
) {
849 o
->format
->event(o
, SR_DF_FRAME_END
, &output_buf
,
852 fwrite(output_buf
, 1, output_len
, outfile
);
863 if (o
&& o
->format
->recv
) {
864 out
= o
->format
->recv(o
, sdi
, packet
);
865 if (out
&& out
->len
) {
866 fwrite(out
->str
, 1, out
->len
, outfile
);
871 /* SR_DF_END needs to be handled after the output module's recv()
872 * is called, so it can properly clean up that module etc. */
873 if (packet
->type
== SR_DF_END
) {
874 g_debug("cli: Received SR_DF_END");
876 if (o
->format
->event
) {
877 o
->format
->event(o
, SR_DF_END
, &output_buf
, &output_len
);
880 fwrite(output_buf
, 1, output_len
, outfile
);
886 if (limit_samples
&& received_samples
< limit_samples
)
887 g_warning("Device only sent %" PRIu64
" samples.",
891 g_warning("Device stopped after %" PRIu64
" samples.",
894 g_array_free(logic_probelist
, TRUE
);
896 if (o
->format
->cleanup
)
897 o
->format
->cleanup(o
);
901 if (outfile
&& outfile
!= stdout
)
904 if (opt_output_file
&& default_output_format
) {
905 if (sr_session_save(opt_output_file
, sdi
, savebuf
->data
,
906 unitsize
, savebuf
->len
/ unitsize
) != SR_OK
)
907 g_critical("Failed to save session.");
908 g_byte_array_free(savebuf
, FALSE
);
915 static int opts_to_gvar(struct srd_decoder
*dec
, GHashTable
*hash
,
916 GHashTable
**options
)
918 struct srd_decoder_option
*o
;
923 char *val_str
, *conv
;
926 *options
= g_hash_table_new_full(g_str_hash
, g_str_equal
, g_free
,
927 (GDestroyNotify
)g_variant_unref
);
929 for (optl
= dec
->options
; optl
; optl
= optl
->next
) {
931 if (!(val_str
= g_hash_table_lookup(hash
, o
->id
)))
934 if (g_variant_is_of_type(o
->def
, G_VARIANT_TYPE_STRING
)) {
935 gvar
= g_variant_new_string(val_str
);
936 } else if (g_variant_is_of_type(o
->def
, G_VARIANT_TYPE_INT64
)) {
937 val_int
= strtoll(val_str
, &conv
, 10);
938 if (!conv
|| conv
== val_str
) {
939 g_critical("Protocol decoder '%s' option '%s' "
940 "requires a number.", dec
->name
, o
->id
);
944 gvar
= g_variant_new_int64(val_int
);
946 g_critical("Unsupported type for option '%s' (%s)",
947 o
->id
, g_variant_get_type_string(o
->def
));
951 g_variant_ref_sink(gvar
);
952 g_hash_table_insert(*options
, g_strdup(o
->id
), gvar
);
953 g_hash_table_remove(hash
, o
->id
);
959 static int probes_to_gvar(struct srd_decoder
*dec
, GHashTable
*hash
,
963 GSList
*all_probes
, *l
;
967 char *val_str
, *conv
;
970 *probes
= g_hash_table_new_full(g_str_hash
, g_str_equal
, g_free
,
971 (GDestroyNotify
)g_variant_unref
);
973 all_probes
= g_slist_copy(dec
->probes
);
974 all_probes
= g_slist_concat(all_probes
, dec
->opt_probes
);
975 for (l
= all_probes
; l
; l
= l
->next
) {
977 if (!(val_str
= g_hash_table_lookup(hash
, p
->id
)))
980 val_int
= strtoll(val_str
, &conv
, 10);
981 if (!conv
|| conv
== val_str
) {
982 g_critical("Protocol decoder '%s' probes '%s' "
983 "is not a number.", dec
->name
, p
->id
);
987 gvar
= g_variant_new_int32(val_int
);
988 g_variant_ref_sink(gvar
);
989 g_hash_table_insert(*probes
, g_strdup(p
->id
), gvar
);
990 g_hash_table_remove(hash
, p
->id
);
992 g_slist_free(all_probes
);
997 /* Register the given PDs for this session.
998 * Accepts a string of the form: "spi:sck=3:sdata=4,spi:sck=3:sdata=5"
999 * That will instantiate two SPI decoders on the clock but different data
1002 static int register_pds(struct sr_dev
*dev
, const char *pdstring
)
1004 struct srd_decoder
*dec
;
1005 GHashTable
*pd_opthash
, *options
, *probes
;
1006 GList
*leftover
, *l
;
1007 struct srd_decoder_inst
*di
;
1009 char **pdtokens
, **pdtok
, *pd_name
;
1014 pd_ann_visible
= g_hash_table_new_full(g_str_hash
, g_int_equal
,
1017 pd_opthash
= options
= probes
= NULL
;
1018 pdtokens
= g_strsplit(pdstring
, ",", 0);
1019 for (pdtok
= pdtokens
; *pdtok
; pdtok
++) {
1020 if (!(pd_opthash
= parse_generic_arg(*pdtok
, TRUE
))) {
1021 g_critical("Invalid protocol decoder option '%s'.", *pdtok
);
1025 pd_name
= g_strdup(g_hash_table_lookup(pd_opthash
, "sigrok_key"));
1026 g_hash_table_remove(pd_opthash
, "sigrok_key");
1027 if (srd_decoder_load(pd_name
) != SRD_OK
) {
1028 g_critical("Failed to load protocol decoder %s.", pd_name
);
1032 dec
= srd_decoder_get_by_id(pd_name
);
1034 /* Convert decoder option and probe values to GVariant. */
1035 if (!opts_to_gvar(dec
, pd_opthash
, &options
)) {
1039 if (!probes_to_gvar(dec
, pd_opthash
, &probes
)) {
1043 if (g_hash_table_size(pd_opthash
) > 0) {
1044 leftover
= g_hash_table_get_keys(pd_opthash
);
1045 for (l
= leftover
; l
; l
= l
->next
)
1046 g_critical("Unknown option or probe '%s'", (char *)l
->data
);
1047 g_list_free(leftover
);
1051 if (!(di
= srd_inst_new(pd_name
, options
))) {
1052 g_critical("Failed to instantiate protocol decoder %s.", pd_name
);
1057 /* If no annotation list was specified, add them all in now.
1058 * This will be pared down later to leave only the last PD
1061 if (!opt_pd_annotations
)
1062 g_hash_table_insert(pd_ann_visible
,
1063 g_strdup(di
->inst_id
), NULL
);
1065 /* Remap the probes if needed. */
1066 if (srd_inst_probe_set_all(di
, probes
) != SRD_OK
) {
1072 g_strfreev(pdtokens
);
1074 g_hash_table_destroy(pd_opthash
);
1076 g_hash_table_destroy(options
);
1078 g_hash_table_destroy(probes
);
1085 int setup_pd_stack(void)
1087 struct srd_decoder_inst
*di_from
, *di_to
;
1091 /* Set up the protocol decoder stack. */
1092 pds
= g_strsplit(opt_pds
, ",", 0);
1093 if (g_strv_length(pds
) > 1) {
1095 /* A stack setup was specified, use that. */
1097 pds
= g_strsplit(opt_pd_stack
, ",", 0);
1098 if (g_strv_length(pds
) < 2) {
1100 g_critical("Specify at least two protocol decoders to stack.");
1105 /* First PD goes at the bottom of the stack. */
1106 ids
= g_strsplit(pds
[0], ":", 0);
1107 if (!(di_from
= srd_inst_find_by_id(ids
[0]))) {
1109 g_critical("Cannot stack protocol decoder '%s': "
1110 "instance not found.", pds
[0]);
1115 /* Every subsequent PD goes on top. */
1116 for (i
= 1; pds
[i
]; i
++) {
1117 ids
= g_strsplit(pds
[i
], ":", 0);
1118 if (!(di_to
= srd_inst_find_by_id(ids
[0]))) {
1120 g_critical("Cannot stack protocol decoder '%s': "
1121 "instance not found.", pds
[i
]);
1125 if ((ret
= srd_inst_stack(di_from
, di_to
)) != SRD_OK
)
1128 /* Don't show annotation from this PD. Only the last PD in
1129 * the stack will be left on the annotation list (unless
1130 * the annotation list was specifically provided).
1132 if (!opt_pd_annotations
)
1133 g_hash_table_remove(pd_ann_visible
,
1144 int setup_pd_annotations(void)
1147 struct srd_decoder
*dec
;
1149 char **pds
, **pdtok
, **keyval
, **ann_descr
;
1151 /* Set up custom list of PDs and annotations to show. */
1152 if (opt_pd_annotations
) {
1153 pds
= g_strsplit(opt_pd_annotations
, ",", 0);
1154 for (pdtok
= pds
; *pdtok
&& **pdtok
; pdtok
++) {
1156 keyval
= g_strsplit(*pdtok
, "=", 0);
1157 if (!(dec
= srd_decoder_get_by_id(keyval
[0]))) {
1158 g_critical("Protocol decoder '%s' not found.", keyval
[0]);
1161 if (!dec
->annotations
) {
1162 g_critical("Protocol decoder '%s' has no annotations.", keyval
[0]);
1165 if (g_strv_length(keyval
) == 2) {
1166 for (l
= dec
->annotations
; l
; l
= l
->next
, ann
++) {
1167 ann_descr
= l
->data
;
1168 if (!canon_cmp(ann_descr
[0], keyval
[1]))
1173 g_critical("Annotation '%s' not found "
1174 "for protocol decoder '%s'.", keyval
[1], keyval
[0]);
1178 g_debug("cli: showing protocol decoder annotation %d from '%s'", ann
, keyval
[0]);
1179 g_hash_table_insert(pd_ann_visible
, g_strdup(keyval
[0]), GINT_TO_POINTER(ann
));
1188 void show_pd_annotations(struct srd_proto_data
*pdata
, void *cb_data
)
1192 gpointer ann_format
;
1194 /* 'cb_data' is not used in this specific callback. */
1197 if (!pd_ann_visible
)
1200 if (!g_hash_table_lookup_extended(pd_ann_visible
, pdata
->pdo
->di
->inst_id
,
1202 /* Not in the list of PDs whose annotations we're showing. */
1205 if (pdata
->ann_format
!= GPOINTER_TO_INT(ann_format
))
1206 /* We don't want this particular format from the PD. */
1209 annotations
= pdata
->data
;
1210 if (opt_loglevel
> SR_LOG_WARN
)
1211 printf("%"PRIu64
"-%"PRIu64
" ", pdata
->start_sample
, pdata
->end_sample
);
1212 printf("%s: ", pdata
->pdo
->proto_id
);
1213 for (i
= 0; annotations
[i
]; i
++)
1214 printf("\"%s\" ", annotations
[i
]);
1220 int setup_output_format(void)
1222 GHashTable
*fmtargs
;
1223 GHashTableIter iter
;
1224 gpointer key
, value
;
1225 struct sr_output_format
**outputs
;
1229 if (!opt_output_format
) {
1230 opt_output_format
= DEFAULT_OUTPUT_FORMAT
;
1231 /* we'll need to remember this so when saving to a file
1232 * later, sigrok session format will be used.
1234 default_output_format
= TRUE
;
1237 fmtargs
= parse_generic_arg(opt_output_format
, TRUE
);
1238 fmtspec
= g_hash_table_lookup(fmtargs
, "sigrok_key");
1240 g_critical("Invalid output format.");
1243 outputs
= sr_output_list();
1244 for (i
= 0; outputs
[i
]; i
++) {
1245 if (strcmp(outputs
[i
]->id
, fmtspec
))
1247 g_hash_table_remove(fmtargs
, "sigrok_key");
1248 output_format
= outputs
[i
];
1249 g_hash_table_iter_init(&iter
, fmtargs
);
1250 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
1251 /* only supporting one parameter per output module
1252 * for now, and only its value */
1253 output_format_param
= g_strdup(value
);
1258 if (!output_format
) {
1259 g_critical("Invalid output format %s.", opt_output_format
);
1262 g_hash_table_destroy(fmtargs
);
1267 static int select_probes(struct sr_dev_inst
*sdi
)
1269 struct sr_probe
*probe
;
1270 GSList
*selected_probes
, *l
;
1275 if (!(selected_probes
= parse_probestring(sdi
, opt_probes
)))
1278 for (l
= sdi
->probes
; l
; l
= l
->next
) {
1280 if (g_slist_find(selected_probes
, probe
))
1281 probe
->enabled
= TRUE
;
1283 probe
->enabled
= FALSE
;
1285 g_slist_free(selected_probes
);
1291 * Return the input file format which the CLI tool should use.
1293 * If the user specified -I / --input-format, use that one. Otherwise, try to
1294 * autodetect the format as good as possible. Failing that, return NULL.
1296 * @param filename The filename of the input file. Must not be NULL.
1297 * @param opt The -I / --input-file option the user specified (or NULL).
1299 * @return A pointer to the 'struct sr_input_format' that should be used,
1300 * or NULL if no input format was selected or auto-detected.
1302 static struct sr_input_format
*determine_input_file_format(
1303 const char *filename
, const char *opt
)
1306 struct sr_input_format
**inputs
;
1308 /* If there are no input formats, return NULL right away. */
1309 inputs
= sr_input_list();
1311 g_critical("No supported input formats available.");
1315 /* If the user specified -I / --input-format, use that one. */
1317 for (i
= 0; inputs
[i
]; i
++) {
1318 if (strcasecmp(inputs
[i
]->id
, opt
))
1320 g_debug("Using user-specified input file format '%s'.",
1325 /* The user specified an unknown input format, return NULL. */
1326 g_critical("Error: specified input file format '%s' is "
1331 /* Otherwise, try to find an input module that can handle this file. */
1332 for (i
= 0; inputs
[i
]; i
++) {
1333 if (inputs
[i
]->format_match(filename
))
1337 /* Return NULL if no input module wanted to touch this. */
1339 g_critical("Error: no matching input module found.");
1343 g_debug("cli: Autodetected '%s' input format for file '%s'.",
1344 inputs
[i
]->id
, filename
);
1349 static void load_input_file_format(void)
1351 GHashTable
*fmtargs
= NULL
;
1353 struct sr_input
*in
;
1354 struct sr_input_format
*input_format
;
1355 char *fmtspec
= NULL
;
1357 if (opt_input_format
) {
1358 fmtargs
= parse_generic_arg(opt_input_format
, TRUE
);
1359 fmtspec
= g_hash_table_lookup(fmtargs
, "sigrok_key");
1362 if (!(input_format
= determine_input_file_format(opt_input_file
,
1364 /* The exact cause was already logged. */
1369 g_hash_table_remove(fmtargs
, "sigrok_key");
1371 if (stat(opt_input_file
, &st
) == -1) {
1372 g_critical("Failed to load %s: %s", opt_input_file
,
1377 /* Initialize the input module. */
1378 if (!(in
= g_try_malloc(sizeof(struct sr_input
)))) {
1379 g_critical("Failed to allocate input module.");
1382 in
->format
= input_format
;
1383 in
->param
= fmtargs
;
1384 if (in
->format
->init
) {
1385 if (in
->format
->init(in
, opt_input_file
) != SR_OK
) {
1386 g_critical("Input format init failed.");
1391 if (select_probes(in
->sdi
) > 0)
1395 sr_session_datafeed_callback_add(datafeed_in
);
1396 if (sr_session_dev_add(in
->sdi
) != SR_OK
) {
1397 g_critical("Failed to use device.");
1398 sr_session_destroy();
1402 input_format
->loadfile(in
, opt_input_file
);
1404 sr_session_destroy();
1407 g_hash_table_destroy(fmtargs
);
1410 static void load_input_file(void)
1413 if (sr_session_load(opt_input_file
) == SR_OK
) {
1414 /* sigrok session file */
1415 sr_session_datafeed_callback_add(datafeed_in
);
1421 /* fall back on input modules */
1422 load_input_file_format();
1426 static int set_dev_options(struct sr_dev_inst
*sdi
, GHashTable
*args
)
1428 const struct sr_config_info
*srci
;
1429 GHashTableIter iter
;
1430 gpointer key
, value
;
1433 uint64_t tmp_u64
, p
, q
;
1435 GVariant
*val
, *rational
[2];
1437 g_hash_table_iter_init(&iter
, args
);
1438 while (g_hash_table_iter_next(&iter
, &key
, &value
)) {
1439 if (!(srci
= sr_config_info_name_get(key
))) {
1440 g_critical("Unknown device option '%s'.", (char *) key
);
1444 if ((value
== NULL
) &&
1445 (srci
->datatype
!= SR_T_BOOL
)) {
1446 g_critical("Option '%s' needs a value.", (char *)key
);
1450 switch (srci
->datatype
) {
1452 ret
= sr_parse_sizestring(value
, &tmp_u64
);
1455 val
= g_variant_new_uint64(tmp_u64
);
1458 val
= g_variant_new_string(value
);
1464 tmp_bool
= sr_parse_boolstring(value
);
1465 val
= g_variant_new_boolean(tmp_bool
);
1468 tmp_double
= strtof(value
, NULL
);
1469 val
= g_variant_new_double(tmp_double
);
1471 case SR_T_RATIONAL_PERIOD
:
1472 if ((ret
= sr_parse_period(value
, &p
, &q
)) != SR_OK
)
1474 rational
[0] = g_variant_new_uint64(p
);
1475 rational
[1] = g_variant_new_uint64(q
);
1476 val
= g_variant_new_tuple(rational
, 2);
1478 case SR_T_RATIONAL_VOLT
:
1479 if ((ret
= sr_parse_voltage(value
, &p
, &q
)) != SR_OK
)
1481 rational
[0] = g_variant_new_uint64(p
);
1482 rational
[1] = g_variant_new_uint64(q
);
1483 val
= g_variant_new_tuple(rational
, 2);
1489 ret
= sr_config_set(sdi
, srci
->key
, val
);
1491 g_critical("Failed to set device option '%s'.", (char *)key
);
1499 static void set_options(void)
1501 struct sr_dev_inst
*sdi
;
1503 GHashTable
*devargs
;
1506 g_critical("No setting specified.");
1510 if (!(devargs
= parse_generic_arg(opt_dev
, FALSE
)))
1513 if (!(devices
= device_scan())) {
1514 g_critical("No devices found.");
1517 sdi
= devices
->data
;
1520 if (sr_session_dev_add(sdi
) != SR_OK
) {
1521 g_critical("Failed to use device.");
1525 set_dev_options(sdi
, devargs
);
1527 sr_session_destroy();
1528 g_slist_free(devices
);
1529 g_hash_table_destroy(devargs
);
1533 static int set_limit_time(const struct sr_dev_inst
*sdi
)
1537 uint64_t samplerate
;
1539 if (!(time_msec
= sr_parse_timestring(opt_time
))) {
1540 g_critical("Invalid time '%s'", opt_time
);
1544 if (sr_dev_has_option(sdi
, SR_CONF_LIMIT_MSEC
)) {
1545 gvar
= g_variant_new_uint64(time_msec
);
1546 if (sr_config_set(sdi
, SR_CONF_LIMIT_MSEC
, gvar
) != SR_OK
) {
1547 g_critical("Failed to configure time limit.");
1550 } else if (sr_dev_has_option(sdi
, SR_CONF_SAMPLERATE
)) {
1551 /* Convert to samples based on the samplerate. */
1552 sr_config_get(sdi
->driver
, SR_CONF_SAMPLERATE
, &gvar
, sdi
);
1553 samplerate
= g_variant_get_uint64(gvar
);
1554 g_variant_unref(gvar
);
1555 limit_samples
= (samplerate
) * time_msec
/ (uint64_t)1000;
1556 if (limit_samples
== 0) {
1557 g_critical("Not enough time at this samplerate.");
1560 gvar
= g_variant_new_uint64(limit_samples
);
1561 if (sr_config_set(sdi
, SR_CONF_LIMIT_SAMPLES
, gvar
) != SR_OK
) {
1562 g_critical("Failed to configure time-based sample limit.");
1566 g_critical("This device does not support time limits.");
1573 static void run_session(void)
1576 GHashTable
*devargs
;
1578 struct sr_dev_inst
*sdi
;
1582 devices
= device_scan();
1584 g_critical("No devices found.");
1587 if (g_slist_length(devices
) > 1) {
1588 g_critical("sigrok-cli only supports one device for capturing.");
1591 sdi
= devices
->data
;
1594 sr_session_datafeed_callback_add(datafeed_in
);
1596 if (sr_session_dev_add(sdi
) != SR_OK
) {
1597 g_critical("Failed to use device.");
1598 sr_session_destroy();
1603 if ((devargs
= parse_generic_arg(opt_dev
, FALSE
))) {
1604 if (set_dev_options(sdi
, devargs
) != SR_OK
)
1606 g_hash_table_destroy(devargs
);
1610 if (select_probes(sdi
) != SR_OK
) {
1611 g_critical("Failed to set probes.");
1612 sr_session_destroy();
1617 if (!(triggerlist
= sr_parse_triggerstring(sdi
, opt_triggers
))) {
1618 sr_session_destroy();
1621 max_probes
= g_slist_length(sdi
->probes
);
1622 for (i
= 0; i
< max_probes
; i
++) {
1623 if (triggerlist
[i
]) {
1624 sr_dev_trigger_set(sdi
, i
, triggerlist
[i
]);
1625 g_free(triggerlist
[i
]);
1628 g_free(triggerlist
);
1631 if (opt_continuous
) {
1632 if (!sr_dev_has_option(sdi
, SR_CONF_CONTINUOUS
)) {
1633 g_critical("This device does not support continuous sampling.");
1634 sr_session_destroy();
1640 if (set_limit_time(sdi
) != SR_OK
) {
1641 sr_session_destroy();
1647 if ((sr_parse_sizestring(opt_samples
, &limit_samples
) != SR_OK
)) {
1648 g_critical("Invalid sample limit '%s'.", opt_samples
);
1649 sr_session_destroy();
1652 gvar
= g_variant_new_uint64(limit_samples
);
1653 if (sr_config_set(sdi
, SR_CONF_LIMIT_SAMPLES
, gvar
) != SR_OK
) {
1654 g_critical("Failed to configure sample limit.");
1655 sr_session_destroy();
1661 if ((sr_parse_sizestring(opt_frames
, &limit_frames
) != SR_OK
)) {
1662 g_critical("Invalid sample limit '%s'.", opt_samples
);
1663 sr_session_destroy();
1666 gvar
= g_variant_new_uint64(limit_frames
);
1667 if (sr_config_set(sdi
, SR_CONF_LIMIT_FRAMES
, gvar
) != SR_OK
) {
1668 g_critical("Failed to configure frame limit.");
1669 sr_session_destroy();
1674 if (sr_session_start() != SR_OK
) {
1675 g_critical("Failed to start session.");
1676 sr_session_destroy();
1688 sr_session_destroy();
1689 g_slist_free(devices
);
1693 static void logger(const gchar
*log_domain
, GLogLevelFlags log_level
,
1694 const gchar
*message
, gpointer cb_data
)
1700 * All messages, warnings, errors etc. go to stderr (not stdout) in
1701 * order to not mess up the CLI tool data output, e.g. VCD output.
1703 if (log_level
& (G_LOG_LEVEL_ERROR
| G_LOG_LEVEL_CRITICAL
| G_LOG_LEVEL_WARNING
)
1704 || opt_loglevel
> SR_LOG_WARN
) {
1705 fprintf(stderr
, "%s\n", message
);
1710 int main(int argc
, char **argv
)
1713 GOptionContext
*context
;
1716 g_log_set_default_handler(logger
, NULL
);
1719 context
= g_option_context_new(NULL
);
1720 g_option_context_add_main_entries(context
, optargs
, NULL
);
1722 if (!g_option_context_parse(context
, &argc
, &argv
, &error
)) {
1723 g_critical("%s", error
->message
);
1727 /* Set the loglevel (amount of messages to output) for libsigrok. */
1728 if (sr_log_loglevel_set(opt_loglevel
) != SR_OK
)
1731 if (sr_init(&sr_ctx
) != SR_OK
)
1735 /* Set the loglevel (amount of messages to output) for libsigrokdecode. */
1736 if (srd_log_loglevel_set(opt_loglevel
) != SRD_OK
)
1740 if (srd_init(NULL
) != SRD_OK
)
1742 if (register_pds(NULL
, opt_pds
) != 0)
1744 if (srd_pd_output_callback_add(SRD_OUTPUT_ANN
,
1745 show_pd_annotations
, NULL
) != SRD_OK
)
1747 if (setup_pd_stack() != 0)
1749 if (setup_pd_annotations() != 0)
1754 if (setup_output_format() != 0)
1759 else if (opt_list_devs
)
1762 else if (opt_pds
&& opt_show
)
1767 else if (opt_input_file
)
1771 else if (opt_samples
|| opt_time
|| opt_frames
|| opt_continuous
)
1774 printf("%s", g_option_context_get_help(context
, TRUE
, NULL
));
1787 g_option_context_free(context
);