X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Finput%2Finput.c;h=8e51e3f96b7285d23611d77b8ac8d46083ce1593;hb=c1aae90038456a61d0f9313d34e6107c3440d3e7;hp=d2c13aa79e18ac017feebbc20d51c9a9455b6762;hpb=0f3dbc9530b94a1cdefa97aee820e9de461cdb48;p=libsigrok.git diff --git a/src/input/input.c b/src/input/input.c index d2c13aa7..8e51e3f9 100644 --- a/src/input/input.c +++ b/src/input/input.c @@ -23,10 +23,12 @@ #include #include #include -#include "libsigrok.h" +#include #include "libsigrok-internal.h" +/** @cond PRIVATE */ #define LOG_PREFIX "input" +/** @endcond */ /** * @file @@ -66,12 +68,11 @@ extern SR_PRIV struct sr_input_module input_wav; /* @endcond */ static const struct sr_input_module *input_module_list[] = { -// &input_vcd, -// &input_chronovu_la8, + &input_binary, + &input_chronovu_la8, + &input_csv, + &input_vcd, &input_wav, -// &input_csv, - /* This one has to be last, because it will take any input. */ -// &input_binary, NULL, }; @@ -90,14 +91,14 @@ SR_API const struct sr_input_module **sr_input_list(void) * * @since 0.4.0 */ -SR_API const char *sr_input_id_get(const struct sr_input_module *o) +SR_API const char *sr_input_id_get(const struct sr_input_module *imod) { - if (!o) { + if (!imod) { sr_err("Invalid input module NULL!"); return NULL; } - return o->id; + return imod->id; } /** @@ -105,14 +106,14 @@ SR_API const char *sr_input_id_get(const struct sr_input_module *o) * * @since 0.4.0 */ -SR_API const char *sr_input_name_get(const struct sr_input_module *o) +SR_API const char *sr_input_name_get(const struct sr_input_module *imod) { - if (!o) { + if (!imod) { sr_err("Invalid input module NULL!"); return NULL; } - return o->name; + return imod->name; } /** @@ -120,14 +121,33 @@ SR_API const char *sr_input_name_get(const struct sr_input_module *o) * * @since 0.4.0 */ -SR_API const char *sr_input_description_get(const struct sr_input_module *o) +SR_API const char *sr_input_description_get(const struct sr_input_module *imod) { - if (!o) { + if (!imod) { sr_err("Invalid input module NULL!"); return NULL; } - return o->desc; + return imod->desc; +} + +/** + * Returns the specified input module's file extensions typical for the file + * format, as a NULL terminated array, or returns a NULL pointer if there is + * no preferred extension. + * @note these are a suggestions only. + * + * @since 0.4.0 + */ +SR_API const char *const *sr_input_extensions_get( + const struct sr_input_module *imod) +{ + if (!imod) { + sr_err("Invalid input module NULL!"); + return NULL; + } + + return imod->exts; } /** @@ -157,39 +177,52 @@ SR_API const struct sr_input_module *sr_input_find(char *id) * * @since 0.4.0 */ -SR_API const struct sr_option *sr_input_options_get(const struct sr_input_module *o) +SR_API const struct sr_option **sr_input_options_get(const struct sr_input_module *imod) { + const struct sr_option *mod_opts, **opts; + int size, i; - if (!o || !o->options) + if (!imod || !imod->options) return NULL; - return o->options(); + mod_opts = imod->options(); + + for (size = 0; mod_opts[size].id; size++) + ; + opts = g_malloc((size + 1) * sizeof(struct sr_option *)); + + for (i = 0; i < size; i++) + opts[i] = &mod_opts[i]; + opts[i] = NULL; + + return opts; } /** * After a call to sr_input_options_get(), this function cleans up all - * resources allocated by that call. + * resources returned by that call. * * @since 0.4.0 */ -SR_API void sr_input_options_free(const struct sr_input_module *o) +SR_API void sr_input_options_free(const struct sr_option **options) { - struct sr_option *opt; + int i; - if (!o || !o->options) + if (!options) return; - for (opt = o->options(); opt->id; opt++) { - if (opt->def) { - g_variant_unref(opt->def); - opt->def = NULL; + for (i = 0; options[i]; i++) { + if (options[i]->def) { + g_variant_unref(options[i]->def); + ((struct sr_option *)options[i])->def = NULL; } - if (opt->values) { - g_slist_free_full(opt->values, (GDestroyNotify)g_variant_unref); - opt->values = NULL; + if (options[i]->values) { + g_slist_free_full(options[i]->values, (GDestroyNotify)g_variant_unref); + ((struct sr_option *)options[i])->values = NULL; } } + g_free(options); } /** @@ -198,8 +231,9 @@ SR_API void sr_input_options_free(const struct sr_input_module *o) * This function is used when a client wants to use a specific input * module to parse a stream. No effort is made to identify the format. * + * @param imod The input module to use. Must not be NULL. * @param options GHashTable consisting of keys corresponding with - * the module options \c id field. The values should be GVariant + * the module options @c id field. The values should be GVariant * pointers with sunk references, of the same GVariantType as the option's * default value. * @@ -219,13 +253,13 @@ SR_API struct sr_input *sr_input_new(const struct sr_input_module *imod, in = g_malloc0(sizeof(struct sr_input)); in->module = imod; - if (options) { - new_opts = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, - (GDestroyNotify)g_variant_unref); + new_opts = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, + (GDestroyNotify)g_variant_unref); + if (imod->options) { mod_opts = imod->options(); for (i = 0; mod_opts[i].id; i++) { - if (g_hash_table_lookup_extended(options, mod_opts[i].id, - &key, &value)) { + if (options && g_hash_table_lookup_extended(options, + mod_opts[i].id, &key, &value)) { /* Option not given: insert the default value. */ gvt = g_variant_get_type(mod_opts[i].def); if (!g_variant_is_of_type(value, gvt)) { @@ -243,37 +277,40 @@ SR_API struct sr_input *sr_input_new(const struct sr_input_module *imod, } /* Make sure no invalid options were given. */ - g_hash_table_iter_init(&iter, options); - while (g_hash_table_iter_next(&iter, &key, &value)) { - if (!g_hash_table_lookup(new_opts, key)) { - sr_err("Input module '%s' has no option '%s'", imod->id, key); - g_hash_table_destroy(new_opts); - g_free(in); - return NULL; + if (options) { + g_hash_table_iter_init(&iter, options); + while (g_hash_table_iter_next(&iter, &key, &value)) { + if (!g_hash_table_lookup(new_opts, key)) { + sr_err("Input module '%s' has no option '%s'", imod->id, key); + g_hash_table_destroy(new_opts); + g_free(in); + return NULL; + } } } - } else - new_opts = NULL; + } if (in->module->init && in->module->init(in, new_opts) != SR_OK) { - g_hash_table_destroy(new_opts); g_free(in); in = NULL; + } else { + in->buf = g_string_sized_new(128); } + if (new_opts) g_hash_table_destroy(new_opts); return in; } -/* Returns TRUE is all required meta items are available. */ +/* Returns TRUE if all required meta items are available. */ static gboolean check_required_metadata(const uint8_t *metadata, uint8_t *avail) { int m, a; uint8_t reqd; for (m = 0; metadata[m]; m++) { - if (!metadata[m] & SR_INPUT_META_REQUIRED) + if (!(metadata[m] & SR_INPUT_META_REQUIRED)) continue; reqd = metadata[m] & ~SR_INPUT_META_REQUIRED; for (a = 0; avail[a]; a++) { @@ -295,23 +332,30 @@ static gboolean check_required_metadata(const uint8_t *metadata, uint8_t *avail) * the input modules to find a match. This is format-dependent, but * 128 bytes is normally enough. * - * If an input module is found, an instance is created and returned. - * Otherwise, NULL is returned. + * If an input module is found, an instance is created into *in. + * Otherwise, *in contains NULL. + * + * If an instance is created, it has the given buffer used for scanning + * already submitted to it, to be processed before more data is sent. + * This allows a frontend to submit an initial chunk of a non-seekable + * stream, such as stdin, without having to keep it around and submit + * it again later. * */ -SR_API const struct sr_input *sr_input_scan_buffer(GString *buf) +SR_API int sr_input_scan_buffer(GString *buf, const struct sr_input **in) { - struct sr_input *in; const struct sr_input_module *imod; GHashTable *meta; unsigned int m, i; + int ret; uint8_t mitem, avail_metadata[8]; /* No more metadata to be had from a buffer. */ avail_metadata[0] = SR_INPUT_META_HEADER; avail_metadata[1] = 0; - in = NULL; + *in = NULL; + ret = SR_ERR; for (i = 0; input_module_list[i]; i++) { imod = input_module_list[i]; if (!imod->metadata[0]) { @@ -334,54 +378,61 @@ SR_API const struct sr_input *sr_input_scan_buffer(GString *buf) g_hash_table_destroy(meta); continue; } - if (!imod->format_match(meta)) { + sr_spew("Trying module %s.", imod->id); + ret = imod->format_match(meta); + g_hash_table_destroy(meta); + if (ret == SR_ERR_DATA) { + /* Module recognized this buffer, but cannot handle it. */ + break; + } else if (ret == SR_ERR) { /* Module didn't recognize this buffer. */ - g_hash_table_destroy(meta); continue; + } else if (ret != SR_OK) { + /* Can be SR_ERR_NA. */ + return ret; } - g_hash_table_destroy(meta); /* Found a matching module. */ - in = sr_input_new(imod, NULL); - in->buf = g_string_new_len(buf->str, buf->len); + sr_spew("Module %s matched.", imod->id); + *in = sr_input_new(imod, NULL); + g_string_insert_len((*in)->buf, 0, buf->str, buf->len); break; } - return in; + return ret; } /** * Try to find an input module that can parse the given file. * - * If an input module is found, an instance is created and returned. - * Otherwise, NULL is returned. + * If an input module is found, an instance is created into *in. + * Otherwise, *in contains NULL. * */ -SR_API const struct sr_input *sr_input_scan_file(const char *filename) +SR_API int sr_input_scan_file(const char *filename, const struct sr_input **in) { - struct sr_input *in; const struct sr_input_module *imod; GHashTable *meta; - GString *buf; + GString *header_buf; struct stat st; unsigned int midx, m, i; - int fd; + int fd, ret; ssize_t size; uint8_t mitem, avail_metadata[8]; if (!filename || !filename[0]) { sr_err("Invalid filename."); - return NULL; + return SR_ERR_ARG; } if (!g_file_test(filename, G_FILE_TEST_EXISTS)) { sr_err("No such file."); - return NULL; + return SR_ERR_ARG; } if (stat(filename, &st) < 0) { sr_err("%s", strerror(errno)); - return NULL; + return SR_ERR_ARG; } midx = 0; @@ -390,9 +441,12 @@ SR_API const struct sr_input *sr_input_scan_file(const char *filename) avail_metadata[midx++] = SR_INPUT_META_HEADER; /* TODO: MIME type */ - in = NULL; - buf = NULL; + *in = NULL; + ret = SR_ERR; + header_buf = g_string_sized_new(128); for (i = 0; input_module_list[i]; i++) { + g_string_truncate(header_buf, 0); + imod = input_module_list[i]; if (!imod->metadata[0]) { /* Module has no metadata for matching so will take @@ -406,28 +460,29 @@ SR_API const struct sr_input *sr_input_scan_file(const char *filename) meta = g_hash_table_new(NULL, NULL); for (m = 0; m < sizeof(imod->metadata); m++) { mitem = imod->metadata[m] & ~SR_INPUT_META_REQUIRED; - if (mitem == SR_INPUT_META_FILENAME) + if (!mitem) + /* Metadata list is 0-terminated. */ + break; + if (mitem == SR_INPUT_META_FILENAME) { g_hash_table_insert(meta, GINT_TO_POINTER(mitem), (gpointer)filename); - else if (mitem == SR_INPUT_META_FILESIZE) + } else if (mitem == SR_INPUT_META_FILESIZE) { g_hash_table_insert(meta, GINT_TO_POINTER(mitem), GINT_TO_POINTER(st.st_size)); - else if (mitem == SR_INPUT_META_HEADER) { - buf = g_string_sized_new(128); + } else if (mitem == SR_INPUT_META_HEADER) { if ((fd = open(filename, O_RDONLY)) < 0) { sr_err("%s", strerror(errno)); - return NULL; + return SR_ERR; } - size = read(fd, buf->str, 128); - buf->len = size; + size = read(fd, header_buf->str, 128); + header_buf->len = size; close(fd); if (size <= 0) { - g_string_free(buf, TRUE); + g_string_free(header_buf, TRUE); sr_err("%s", strerror(errno)); - return NULL; + return SR_ERR; } - g_hash_table_insert(meta, GINT_TO_POINTER(mitem), buf); - g_string_free(buf, TRUE); + g_hash_table_insert(meta, GINT_TO_POINTER(mitem), header_buf); } } if (g_hash_table_size(meta) == 0) { @@ -436,30 +491,46 @@ SR_API const struct sr_input *sr_input_scan_file(const char *filename) g_hash_table_destroy(meta); continue; } - if (!imod->format_match(meta)) + sr_spew("Trying module %s.", imod->id); + ret = imod->format_match(meta); + g_hash_table_destroy(meta); + if (ret == SR_ERR_DATA) { + /* Module recognized this buffer, but cannot handle it. */ + break; + } else if (ret == SR_ERR) { /* Module didn't recognize this buffer. */ continue; + } else if (ret != SR_OK) { + /* Can be SR_ERR_NA. */ + return ret; + } /* Found a matching module. */ - in = sr_input_new(imod, NULL); - in->buf = g_string_new_len(buf->str, buf->len); + sr_spew("Module %s matched.", imod->id); + *in = sr_input_new(imod, NULL); break; } - if (!in && buf) - g_string_free(buf, TRUE); + g_string_free(header_buf, TRUE); - return in; + return ret; } /** * Return the input instance's (virtual) device instance. This can be * used to find out the number of channels and other information. * + * If the device instance has not yet been fully populated by the input + * module, NULL is returned. This indicates the module needs more data + * to identify the number of channels and so on. + * * @since 0.4.0 */ SR_API struct sr_dev_inst *sr_input_dev_inst_get(const struct sr_input *in) { - return in->sdi; + if (in->sdi_ready) + return in->sdi; + else + return NULL; } /** @@ -468,34 +539,55 @@ SR_API struct sr_dev_inst *sr_input_dev_inst_get(const struct sr_input *in) * When an input module instance is created with sr_input_new(), this * function is used to feed data to the instance. * + * As enough data gets fed into this function to completely populate + * the device instance associated with this input instance, this is + * guaranteed to return the moment it's ready. This gives the caller + * the chance to examine the device instance, attach session callbacks + * and so on. + * * @since 0.4.0 */ SR_API int sr_input_send(const struct sr_input *in, GString *buf) { - return in->module->receive(in, buf); + sr_spew("Sending %d bytes to %s module.", buf->len, in->module->id); + return in->module->receive((struct sr_input *)in, buf); } /** - * Free the specified input instance and all associated resources. + * Signal the input module no more data will come. + * + * This will cause the module to process any data it may have buffered. + * The SR_DF_END packet will also typically be sent at this time. * * @since 0.4.0 */ -SR_API int sr_input_free(const struct sr_input *in) +SR_API int sr_input_end(const struct sr_input *in) { - int ret; + sr_spew("Calling end() on %s module.", in->module->id); + return in->module->end((struct sr_input *)in); +} +/** + * Free the specified input instance and all associated resources. + * + * @since 0.4.0 + */ +SR_API void sr_input_free(const struct sr_input *in) +{ if (!in) - return SR_ERR_ARG; + return; - ret = SR_OK; if (in->module->cleanup) - ret = in->module->cleanup((struct sr_input *)in); - if (in->buf) - g_string_free(in->buf, TRUE); + in->module->cleanup((struct sr_input *)in); + if (in->sdi) + sr_dev_inst_free(in->sdi); + if (in->buf->len > 64) { + /* That seems more than just some sub-unitsize leftover... */ + sr_warn("Found %d unprocessed bytes at free time.", in->buf->len); + } + g_string_free(in->buf, TRUE); + g_free(in->priv); g_free((gpointer)in); - - return ret; } - /** @} */