X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Finput%2Finput.c;h=287fcede93c2fa12295fb9eb41d1e8dbccec2636;hb=89da5b3b54d3b87bff49e716c4d2b36080fe7a07;hp=16185aaab39c916c0941bd4ed96e8a82cfb4855b;hpb=57486a7528f8a646bbc6d22994a8f5effd3cacf9;p=libsigrok.git

diff --git a/src/input/input.c b/src/input/input.c
index 16185aaa..287fcede 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,
 };
 
@@ -309,23 +308,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 +354,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_OK_CONTINUE. */
+			return ret;
 		}
-		g_hash_table_destroy(meta);
 
 		/* Found a matching module. */
-		in = sr_input_new(imod, NULL);
-		g_string_insert_len(in->buf, 0, 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 +417,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 +436,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 +467,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_OK_CONTINUE. */
+			return ret;
+		}
 
 		/* Found a matching module. */
-		in = sr_input_new(imod, NULL);
-		g_string_insert_len(in->buf, 0, 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,11 +515,18 @@ 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 on so.
+ *
  * @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);
 }
 
 /**
@@ -506,8 +546,13 @@ SR_API int sr_input_free(const struct sr_input *in)
 		ret = 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);
+	}
 	if (in->buf)
 		g_string_free(in->buf, TRUE);
+	g_free(in->priv);
 	g_free((gpointer)in);
 
 	return ret;