X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Finput%2Finput.c;h=3c7fd516a309ea7e05aff2da1b3c16a592355d6a;hb=a160a0c344f5bcb24eeb01c5698f3a50eaee7d79;hp=36f63e1dfa507e918a09fb340020e3f45d709a16;hpb=fe4fe25bf5afdcab336e2fc10625c77720733ded;p=libsigrok.git diff --git a/src/input/input.c b/src/input/input.c index 36f63e1d..3c7fd516 100644 --- a/src/input/input.c +++ b/src/input/input.c @@ -66,12 +66,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, }; @@ -270,17 +269,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 +310,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 +356,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 +419,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 +438,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 +469,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,35 +517,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; }