X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Finput%2Finput.c;h=8e51e3f96b7285d23611d77b8ac8d46083ce1593;hb=c1aae90038456a61d0f9313d34e6107c3440d3e7;hp=36f63e1dfa507e918a09fb340020e3f45d709a16;hpb=fe4fe25bf5afdcab336e2fc10625c77720733ded;p=libsigrok.git diff --git a/src/input/input.c b/src/input/input.c index 36f63e1d..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_binary, + &input_chronovu_la8, + &input_csv, &input_vcd, -// &input_chronovu_la8, &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; } /** @@ -211,8 +231,9 @@ SR_API void sr_input_options_free(const struct sr_option **options) * 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. * @@ -270,17 +291,19 @@ SR_API struct sr_input *sr_input_new(const struct sr_input_module *imod, } 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; @@ -309,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]) { @@ -348,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; @@ -404,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 @@ -420,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) { @@ -450,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; } /** @@ -482,36 +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); + in->module->cleanup((struct sr_input *)in); if (in->sdi) sr_dev_inst_free(in->sdi); - if (in->buf) - g_string_free(in->buf, TRUE); + 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; } - /** @} */