input/logicport: introduce input module for LogicPort File (*.lpf)

[libsigrok.git] / src / input / logicport.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2018 Gerhard Sittig <gerhard.sittig@gmx.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

/*
 * See the LA1034 vendor's http://www.pctestinstruments.com/ website.
 *
 * The hardware comes with (Windows only) software which uses the .lpf
 * ("LogicPort File") filename extension for project files, which hold
 * both the configuration as well as sample data (up to 2K samples). In
 * the absence of an attached logic analyzer, the software provides a
 * demo mode which generates random input signals. The software installs
 * example project files (with samples), too.
 *
 * The file format is "mostly text", is line oriented, though it uses
 * funny DC1 separator characters as well as line continuation by means
 * of a combination of DC1 and slashes. Fortunately the last text line
 * is terminated by means of CRLF.
 *
 * The software is rather complex and has features which don't easily
 * translate to sigrok semantics (like one signal being a member of
 * multiple groups, display format specs for groups' values).
 *
 * This input module implementation supports the following features:
 * - input format auto detection
 * - sample period to sample rate conversion
 * - wire names, acquisition filters ("enabled") and inversion flags
 * - decompression (repetition counters for sample data)
 * - strict '0' and '1' levels (as well as ignoring 'U' values)
 * - signal names (user assigned names, "aliases" for "wires")
 * - signal groups (no support for multiple assignments, no support for
 *   display format specs)
 * - "logic" channels (mere bits, no support for analog channels, also
 *   nothing analog "gets derived from" any signal groups) -- libsigrok
 *   using applications might provide such a feature if they want to
 */

#include <config.h>
#include <ctype.h>
#include <glib.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"

/* TODO: Move these helpers to some library API routine group. */
struct sr_channel_group *sr_channel_group_new(const char *name, void *priv);
void sr_channel_group_free(struct sr_channel_group *cg);

#define LOG_PREFIX	"input/logicport"

#define MAX_CHANNELS	34
#define CHUNK_SIZE	(4 * 1024 * 1024)

#define CRLF		"\r\n"
#define DC1_CHR		'\x11'
#define DC1_STR		"\x11"
#define CONT_OPEN	"/" DC1_STR
#define CONT_CLOSE	DC1_STR "/"

/*
 * This is some heuristics (read: a HACK). The current implementation
 * neither processes nor displays the user's notes, but takes their
 * presence as a hint that all relevant input was seen, and sample data
 * can get forwarded to the session bus.
 */
#define LAST_KEYWORD	"NotesString"

/*
 * The vendor software supports signal groups, and a single signal can
 * be a member in multiple groups at the same time. The sigrok project
 * does not support that configuration. Let's ignore the "All Signals"
 * group by default, thus reducing the probability of a conflict.
 */
#define SKIP_SIGNAL_GROUP	"All Signals"

struct signal_group_desc {
	char *name;
	uint64_t mask;
};

struct context {
	gboolean got_header;
	gboolean ch_feed_prep;
	gboolean header_sent;
	gboolean rate_sent;
	char *sw_version;
	size_t sw_build;
	GString *cont_buff;
	size_t channel_count;
	size_t sample_lines_total;
	size_t sample_lines_read;
	size_t sample_lines_fed;
	uint64_t samples_got_uncomp;
	enum {
		SAMPLEDATA_NONE,
		SAMPLEDATA_OPEN_BRACE,
		SAMPLEDATA_WIRES_COUNT,
		SAMPLEDATA_DATA_LINES,
		SAMPLEDATA_CLOSE_BRACE,
	} in_sample_data;
	struct sample_data_entry {
		uint64_t bits;
		size_t repeat;
	} *sample_data_queue;
	uint64_t sample_rate;
	uint64_t wires_all_mask;
	uint64_t wires_enabled;
	uint64_t wires_inverted;
	uint64_t wires_undefined;
	char *wire_names[MAX_CHANNELS];
	char *signal_names[MAX_CHANNELS];
	uint64_t wires_grouped;
	GSList *signal_groups;
	GSList *channels;
	size_t unitsize;
	size_t samples_per_chunk;
	size_t samples_in_buffer;
	uint8_t *feed_buffer;
};

static struct signal_group_desc *alloc_signal_group(const char *name)
{
	struct signal_group_desc *desc;

	desc = g_malloc0(sizeof(*desc));
	if (!desc)
		return NULL;
	if (name) {
		desc->name = g_strdup(name);
		if (!desc->name) {
			g_free(desc);
			return NULL;
		}
	}

	return desc;
}

static void free_signal_group(struct signal_group_desc *desc)
{
	if (!desc)
		return;
	g_free(desc->name);
	g_free(desc);
}

struct sr_channel_group *sr_channel_group_new(const char *name, void *priv)
{
	struct sr_channel_group *cg;

	cg = g_malloc0(sizeof(*cg));
	if (!cg)
		return NULL;
	if (name && *name) {
		cg->name = g_strdup(name);
		if (!cg->name) {
			g_free(cg);
			return NULL;
		}
	}
	cg->priv = priv;

	return cg;
}

void sr_channel_group_free(struct sr_channel_group *cg)
{
	if (!cg)
		return;
	g_free(cg->name);
	g_slist_free(cg->channels);
}

/* Wrapper for GDestroyNotify compatibility. */
static void sg_free(void *p)
{
	return free_signal_group(p);
}

static int check_vers_line(char *line, int need_key,
	gchar **version, gchar **build)
{
	static const char *keyword = "Version";
	static const char *caution = " CAUTION: Do not change the contents of this file.";
	char *read_ptr;
	const char *prev_ptr;

	read_ptr = line;
	if (version)
		*version = NULL;
	if (build)
		*build = NULL;

	/* Expect the 'Version' literal, followed by a DC1 separator. */
	if (need_key) {
		if (strncmp(read_ptr, keyword, strlen(keyword)) != 0)
			return SR_ERR_DATA;
		read_ptr += strlen(keyword);
		if (*read_ptr != DC1_CHR)
			return SR_ERR_DATA;
		read_ptr++;
	}

	/* Expect some "\d+\.\d+" style version string and DC1. */
	if (!*read_ptr)
		return SR_ERR_DATA;
	if (version)
		*version = read_ptr;
	prev_ptr = read_ptr;
	read_ptr += strspn(read_ptr, "0123456789.");
	if (read_ptr == prev_ptr)
		return SR_ERR_DATA;
	if (*read_ptr != DC1_CHR)
		return SR_ERR_DATA;
	*read_ptr++ = '\0';

	/* Expect some "\d+" style build number and DC1. */
	if (!*read_ptr)
		return SR_ERR_DATA;
	if (build)
		*build = read_ptr;
	prev_ptr = read_ptr;
	read_ptr += strspn(read_ptr, "0123456789");
	if (read_ptr == prev_ptr)
		return SR_ERR_DATA;
	if (*read_ptr != DC1_CHR)
		return SR_ERR_DATA;
	*read_ptr++ = '\0';

	/* Expect the 'CAUTION...' text (weak test, only part of the text). */
	if (strncmp(read_ptr, caution, strlen(caution)) != 0)
		return SR_ERR_DATA;
	read_ptr += strlen(caution);

	/* No check for CRLF, due to the weak CAUTION test. */
	return SR_OK;
}

static int process_wire_names(struct context *inc, char **names)
{
	size_t count, idx;

	/*
	 * The 'names' array contains the *wire* names, plus a 'Count'
	 * label for the last column.
	 */
	count = g_strv_length(names);
	if (count != inc->channel_count + 1)
		return SR_ERR_DATA;
	if (strcmp(names[inc->channel_count], "Count") != 0)
		return SR_ERR_DATA;

	for (idx = 0; idx < inc->channel_count; idx++)
		inc->wire_names[idx] = g_strdup(names[idx]);

	return SR_OK;
}

static int process_signal_names(struct context *inc, char **names)
{
	size_t count, idx;

	/*
	 * The 'names' array contains the *signal* names (and no other
	 * entries, unlike the *wire* names).
	 */
	count = g_strv_length(names);
	if (count != inc->channel_count)
		return SR_ERR_DATA;

	for (idx = 0; idx < inc->channel_count; idx++)
		inc->signal_names[idx] = g_strdup(names[idx]);

	return SR_OK;
}

static int process_signal_group(struct context *inc, char **args)
{
	char *name, *wires;
	struct signal_group_desc *desc;
	uint64_t bit_tmpl, bit_mask;
	char *p, *endp;
	size_t idx;

	/*
	 * List of arguments that we receive:
	 * - [0] group name
	 * - [1] - [5] uncertain meaning, four integers and one boolean
	 * - [6] comma separated list of wire indices (zero based)
	 * - [7] - [9] uncertain meaning, a boolean, two integers
	 * - [10] - [35] uncertain meaning, 26 empty columns
	 */

	/* Check for the minimum amount of input data. */
	if (!args)
		return SR_ERR_DATA;
	if (g_strv_length(args) < 7)
		return SR_ERR_DATA;
	name = args[0];
	wires = args[6];

	/* Accept empty names and empty signal lists. Silently ignore. */
	if (!name || !*name)
		return SR_OK;
	if (!wires || !*wires)
		return SR_OK;
	/*
	 * TODO: Introduce a user configurable "ignore" option? Skip the
	 * "All Signals" group by default, and in addition whatever
	 * the user specified?
	 */
	if (strcmp(name, SKIP_SIGNAL_GROUP) == 0) {
		sr_info("Skipping signal group '%s'", name);
		return SR_OK;
	}

	/*
	 * Create the descriptor here to store the member list to. We
	 * cannot access signal names and sigrok channels yet, they
	 * only become avilable at a later point in time.
	 */
	desc = alloc_signal_group(name);
	if (!desc)
		return SR_ERR_MALLOC;
	inc->signal_groups = g_slist_append(inc->signal_groups, desc);

	/*
	 * Determine the bit mask of the group's signals' indices.
	 *
	 * Implementation note: Use a "template" for a single bit, to
	 * avoid portability issues with upper bits. Without this 64bit
	 * intermediate variable, I would not know how to phrase e.g.
	 * (1ULL << 33) in portable, robust, and easy to maintain ways
	 * on all platforms that are supported by sigrok.
	 */
	bit_tmpl = 1UL << 0;
	bit_mask = 0;
	p = wires;
	while (p && *p) {
		endp = NULL;
		idx = strtoul(p, &endp, 0);
		if (!endp || endp == p)
			return SR_ERR_DATA;
		if (*endp && *endp != ',')
			return SR_ERR_DATA;
		p = endp;
		if (*p == ',')
			p++;
		if (idx >= MAX_CHANNELS)
			return SR_ERR_DATA;
		bit_mask = bit_tmpl << idx;
		if (inc->wires_grouped & bit_mask) {
			sr_warn("Not adding signal at index %zu to group %s (multiple assignments)",
				idx, name);
		} else {
			desc->mask |= bit_mask;
			inc->wires_grouped |= bit_mask;
		}
	}
	sr_dbg("'Group' done, name '%s', mask 0x%" PRIx64 ".",
		desc->name, desc->mask);

	return SR_OK;
}

static int process_ungrouped_signals(struct context *inc)
{
	uint64_t bit_mask;
	struct signal_group_desc *desc;

	/*
	 * Only create the "ungrouped" channel group if there are any
	 * groups of other signals already.
	 */
	if (!inc->signal_groups)
		return SR_OK;

	/*
	 * Determine the bit mask of signals that are part of the
	 * acquisition and are not a member of any other group.
	 */
	bit_mask = inc->wires_all_mask;
	bit_mask &= inc->wires_enabled;
	bit_mask &= ~inc->wires_grouped;
	sr_dbg("'ungrouped' check: all 0x%" PRIx64 ", en 0x%" PRIx64 ", grp 0x%" PRIx64 " -> un 0x%" PRIx64 ".",
		inc->wires_all_mask, inc->wires_enabled,
		inc->wires_grouped, bit_mask);
	if (!bit_mask)
		return SR_OK;

	/* Create a sigrok channel group without a name. */
	desc = alloc_signal_group(NULL);
	if (!desc)
		return SR_ERR_MALLOC;
	inc->signal_groups = g_slist_append(inc->signal_groups, desc);
	desc->mask = bit_mask;

	return SR_OK;
}

static int process_enabled_channels(struct context *inc, char **flags)
{
	size_t count, idx;
	uint64_t bits, mask;

	/*
	 * The 'flags' array contains (the textual representation of)
	 * the "enabled" state of the acquisition device's channels.
	 */
	count = g_strv_length(flags);
	if (count != inc->channel_count)
		return SR_ERR_DATA;
	bits = 0;
	mask = 1UL << 0;
	for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
		if (strcmp(flags[idx], "True") == 0)
			bits |= mask;
	}
	inc->wires_enabled = bits;

	return SR_OK;
}

static int process_inverted_channels(struct context *inc, char **flags)
{
	size_t count, idx;
	uint64_t bits, mask;

	/*
	 * The 'flags' array contains (the textual representation of)
	 * the "inverted" state of the acquisition device's channels.
	 */
	count = g_strv_length(flags);
	if (count != inc->channel_count)
		return SR_ERR_DATA;
	bits = 0;
	mask = 1UL << 0;
	for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
		if (strcmp(flags[idx], "True") == 0)
			bits |= mask;
	}
	inc->wires_inverted = bits;

	return SR_OK;
}

static int process_sample_line(struct context *inc, char **values)
{
	size_t count, idx;
	struct sample_data_entry *entry;
	uint64_t mask;
	long conv_ret;
	int rc;

	/*
	 * The 'values' array contains '0'/'1' text representation of
	 * wire's values, as well as a (a textual representation of a)
	 * repeat counter for that set of samples.
	 */
	count = g_strv_length(values);
	if (count != inc->channel_count + 1)
		return SR_ERR_DATA;
	entry = &inc->sample_data_queue[inc->sample_lines_read];
	entry->bits = 0;
	mask = 1UL << 0;
	for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
		if (strcmp(values[idx], "1") == 0)
			entry->bits |= mask;
		if (strcmp(values[idx], "U") == 0)
			inc->wires_undefined |= mask;
	}
	rc = sr_atol(values[inc->channel_count], &conv_ret);
	if (rc != SR_OK)
		return rc;
	entry->repeat = conv_ret;
	inc->samples_got_uncomp += entry->repeat;

	return SR_OK;
}

static int process_keyvalue_line(struct context *inc, char *line)
{
	char *sep, *key, *arg;
	char **args;
	int rc;
	char *version, *build;
	long build_num;
	int wires, samples;
	size_t alloc_size;
	double period, dbl_rate;
	uint64_t int_rate;

	/*
	 * Process lines of the 'SampleData' block. Inspection of the
	 * block got started below in the "regular keyword line" section.
	 * The code here handles the remaining number of lines: Opening
	 * and closing braces, wire names, and sample data sets. Note
	 * that the wire names and sample values are separated by comma,
	 * not by DC1 like other key/value pairs and argument lists.
	 */
	switch (inc->in_sample_data) {
	case SAMPLEDATA_OPEN_BRACE:
		if (strcmp(line, "{") != 0)
			return SR_ERR_DATA;
		inc->in_sample_data++;
		return SR_OK;
	case SAMPLEDATA_WIRES_COUNT:
		while (isspace(*line))
			line++;
		args = g_strsplit(line, ",", 0);
		rc = process_wire_names(inc, args);
		g_strfreev(args);
		if (rc)
			return rc;
		inc->in_sample_data++;
		inc->sample_lines_read = 0;
		return SR_OK;
	case SAMPLEDATA_DATA_LINES:
		while (isspace(*line))
			line++;
		args = g_strsplit(line, ",", 0);
		rc = process_sample_line(inc, args);
		g_strfreev(args);
		if (rc)
			return rc;
		inc->sample_lines_read++;
		if (inc->sample_lines_read == inc->sample_lines_total)
			inc->in_sample_data++;
		return SR_OK;
	case SAMPLEDATA_CLOSE_BRACE:
		if (strcmp(line, "}") != 0)
			return SR_ERR_DATA;
		sr_dbg("'SampleData' done: samples count %" PRIu64 ".",
			inc->samples_got_uncomp);
		inc->sample_lines_fed = 0;
		inc->in_sample_data = SAMPLEDATA_NONE;
		return SR_OK;
	case SAMPLEDATA_NONE:
		/* EMPTY */ /* Fall through to regular keyword-line logic. */
		break;
	}

	/* Process regular key/value lines separated by DC1. */
	key = line;
	sep = strchr(line, DC1_CHR);
	if (!sep)
		return SR_ERR_DATA;
	*sep++ = '\0';
	arg = sep;
	if (strcmp(key, "Version") == 0) {
		rc = check_vers_line(arg, 0, &version, &build);
		if (rc == SR_OK) {
			inc->sw_version = g_strdup(version ? version : "?");
			rc = sr_atol(build, &build_num);
			inc->sw_build = build_num;
		}
		sr_dbg("'Version' line: version %s, build %zu.",
			inc->sw_version, inc->sw_build);
		return rc;
	}
	if (strcmp(key, "AcquiredSamplePeriod") == 0) {
		rc = sr_atod(arg, &period);
		if (rc != SR_OK)
			return rc;
		/*
		 * Implementation detail: The vendor's software provides
		 * 1/2/5 choices in the 1kHz - 500MHz range. Unfortunately
		 * the choice of saving the sample _period_ as a floating
		 * point number in the text file yields inaccurate results
		 * for naive implementations of the conversion (0.1 is an
		 * "odd number" in the computer's internal representation).
		 * The below logic of rounding to integer and then rounding
		 * to full kHz works for the samplerate value's range.
		 * "Simplifying" the implementation will introduce errors.
		 */
		dbl_rate = 1.0 / period;
		int_rate = (uint64_t)(dbl_rate + 0.5);
		int_rate += 500;
		int_rate /= 1000;
		int_rate *= 1000;
		inc->sample_rate = int_rate;
		if (!inc->sample_rate)
			return SR_ERR_DATA;
		sr_dbg("Sample rate: %" PRIu64 ".", inc->sample_rate);
		return SR_OK;
	}
	if (strcmp(key, "AcquiredChannelList") == 0) {
		args = g_strsplit(arg, DC1_STR, 0);
		rc = process_enabled_channels(inc, args);
		g_strfreev(args);
		if (rc)
			return rc;
		sr_dbg("Enabled channels: 0x%" PRIx64 ".",
			inc->wires_enabled);
		return SR_OK;
	}
	if (strcmp(key, "InvertedChannelList") == 0) {
		args = g_strsplit(arg, DC1_STR, 0);
		rc = process_inverted_channels(inc, args);
		g_strfreev(args);
		sr_dbg("Inverted channels: 0x%" PRIx64 ".",
			inc->wires_inverted);
		return SR_OK;
	}
	if (strcmp(key, "Signals") == 0) {
		args = g_strsplit(arg, DC1_STR, 0);
		rc = process_signal_names(inc, args);
		g_strfreev(args);
		if (rc)
			return rc;
		sr_dbg("Got signal names.");
		return SR_OK;
	}
	if (strcmp(key, "SampleData") == 0) {
		args = g_strsplit(arg, DC1_STR, 3);
		if (!args || !args[0] || !args[1]) {
			g_strfreev(args);
			return SR_ERR_DATA;
		}
		rc = sr_atoi(args[0], &wires);
		if (rc) {
			g_strfreev(args);
			return SR_ERR_DATA;
		}
		rc = sr_atoi(args[1], &samples);
		if (rc) {
			g_strfreev(args);
			return SR_ERR_DATA;
		}
		g_strfreev(args);
		if (!wires || !samples)
			return SR_ERR_DATA;
		inc->channel_count = wires;
		inc->sample_lines_total = samples;
		sr_dbg("'SampleData' start: wires %zu, sample lines %zu.",
			inc->channel_count, inc->sample_lines_total);
		if (inc->channel_count > MAX_CHANNELS)
			return SR_ERR_DATA;
		inc->in_sample_data = SAMPLEDATA_OPEN_BRACE;
		alloc_size = sizeof(inc->sample_data_queue[0]);
		alloc_size *= inc->sample_lines_total;
		inc->sample_data_queue = g_malloc0(alloc_size);
		if (!inc->sample_data_queue)
			return SR_ERR_DATA;
		inc->sample_lines_fed = 0;
		return SR_OK;
	}
	if (strcmp(key, "Group") == 0) {
		args = g_strsplit(arg, DC1_STR, 0);
		rc = process_signal_group(inc, args);
		g_strfreev(args);
		if (rc)
			return rc;
		return SR_OK;
	}
	if (strcmp(key, LAST_KEYWORD) == 0) {
		sr_dbg("'" LAST_KEYWORD "' seen, assuming \"header done\".");
		inc->got_header = TRUE;
		return SR_OK;
	}

	/* Unsupported keyword, silently ignore the line. */
	return SR_OK;
}

/* Check for, and isolate another line of text input. */
static int have_text_line(struct sr_input *in, char **line, char **next)
{
	char *sol_ptr, *eol_ptr;

	if (!in || !in->buf || !in->buf->str)
		return 0;
	sol_ptr = in->buf->str;
	eol_ptr = strstr(sol_ptr, CRLF);
	if (!eol_ptr)
		return 0;
	if (line)
		*line = sol_ptr;
	*eol_ptr = '\0';
	eol_ptr += strlen(CRLF);
	if (next)
		*next = eol_ptr;

	return 1;
}

/* Handle line continuation. Have logical lines processed. */
static int process_text_line(struct context *inc, char *line)
{
	char *p;
	int is_cont_end;
	int rc;

	/*
	 * Handle line continuation in the input stream. Notice that
	 * continued lines can start and end on the same input line.
	 * The text between the markers can be empty, too.
	 *
	 * Make the result look like a regular line. Put a DC1 delimiter
	 * between the keyword and the right hand side. Strip the /<DC1>
	 * and <DC1>/ "braces". Put CRLF between all continued parts,
	 * this makes the data appear "most intuitive and natural"
	 * should we e.g. pass on user's notes in a future version.
	 */
	is_cont_end = 0;
	if (!inc->cont_buff) {
		p = strstr(line, CONT_OPEN);
		if (p) {
			/* Start of continuation. */
			inc->cont_buff = g_string_new_len(line, p - line + 1);
			inc->cont_buff->str[inc->cont_buff->len - 1] = DC1_CHR;
			line = p + strlen(CONT_OPEN);
		}
		/* Regular line, fall through to below regular logic. */
	}
	if (inc->cont_buff) {
		p = strstr(line, CONT_CLOSE);
		is_cont_end = p != NULL;
		if (is_cont_end)
			*p = '\0';
		g_string_append_len(inc->cont_buff, line, strlen(line));
		if (!is_cont_end) {
			/* Keep accumulating. */
			g_string_append_len(inc->cont_buff, CRLF, strlen(CRLF));
			return SR_OK;
		}
		/* End of continuation. */
		line = inc->cont_buff->str;
	}

	/*
	 * Process a logical line of input. It either was received from
	 * the caller, or is the result of accumulating continued lines.
	 */
	rc = process_keyvalue_line(inc, line);

	/* Release the accumulation buffer when a continuation ended. */
	if (is_cont_end) {
		g_string_free(inc->cont_buff, TRUE);
		inc->cont_buff = NULL;
	}

	return rc;
}

/* Tell whether received data is sufficient for session feed preparation. */
static int have_header(GString *buf)
{
	const char *assumed_last_key = CRLF LAST_KEYWORD CONT_OPEN;

	if (strstr(buf->str, assumed_last_key))
		return TRUE;

	return FALSE;
}

/* Process/inspect previously received input data. Get header parameters. */
static int parse_header(struct sr_input *in)
{
	struct context *inc;
	char *line, *next;
	int rc;

	inc = in->priv;
	while (have_text_line(in, &line, &next)) {
		rc = process_text_line(inc, line);
		g_string_erase(in->buf, 0, next - line);
		if (rc)
			return rc;
	}

	return SR_OK;
}

/* Create sigrok channels and groups. Allocate the session feed buffer. */
static int create_channels_groups_buffer(struct sr_input *in)
{
	struct context *inc;
	uint64_t mask;
	size_t idx;
	const char *name;
	gboolean enabled;
	struct sr_channel *ch;
	struct sr_dev_inst *sdi;
	GSList *l;
	struct signal_group_desc *desc;
	struct sr_channel_group *cg;

	inc = in->priv;

	mask = 1UL << 0;
	for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
		name = inc->signal_names[idx];
		if (!name || !*name)
			name = inc->wire_names[idx];
		enabled = (inc->wires_enabled & mask) ? TRUE : FALSE;
		ch = sr_channel_new(in->sdi, idx,
			SR_CHANNEL_LOGIC, enabled, name);
		if (!ch)
			return SR_ERR_MALLOC;
		inc->channels = g_slist_append(inc->channels, ch);
	}

	sdi = in->sdi;
	for (l = inc->signal_groups; l; l = l->next) {
		desc = l->data;
		cg = sr_channel_group_new(desc->name, NULL);
		if (!cg)
			return SR_ERR_MALLOC;
		sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
		mask = 1UL << 0;
		for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
			if (!(desc->mask & mask))
				continue;
			ch = g_slist_nth_data(inc->channels, idx);
			if (!ch)
				return SR_ERR_DATA;
			cg->channels = g_slist_append(cg->channels, ch);
		}
	}

	inc->unitsize = (inc->channel_count + 7) / 8;
	inc->samples_per_chunk = CHUNK_SIZE / inc->unitsize;
	inc->samples_in_buffer = 0;
	inc->feed_buffer = g_malloc0(inc->samples_per_chunk * inc->unitsize);
	if (!inc->feed_buffer)
		return SR_ERR_MALLOC;

	return SR_OK;
}

/* Send all accumulated sample data values to the session. */
static int send_buffer(struct sr_input *in)
{
	struct context *inc;
	struct sr_datafeed_packet packet;
	struct sr_datafeed_meta meta;
	struct sr_config *src;
	struct sr_datafeed_logic logic;
	int rc;

	inc = in->priv;
	if (!inc->samples_in_buffer)
		return SR_OK;

	if (!inc->header_sent) {
		rc = std_session_send_df_header(in->sdi);
		if (rc)
			return rc;
		inc->header_sent = TRUE;
	}

	if (inc->sample_rate && !inc->rate_sent) {
		packet.type = SR_DF_META;
		packet.payload = &meta;
		src = sr_config_new(SR_CONF_SAMPLERATE,
			g_variant_new_uint64(inc->sample_rate));
		meta.config = g_slist_append(NULL, src);
		rc = sr_session_send(in->sdi, &packet);
		g_slist_free(meta.config);
		sr_config_free(src);
		if (rc)
			return rc;
		inc->rate_sent = TRUE;
	}

	packet.type = SR_DF_LOGIC;
	packet.payload = &logic;
	logic.unitsize = inc->unitsize;
	logic.data = inc->feed_buffer;
	logic.length = inc->unitsize * inc->samples_in_buffer;
	rc = sr_session_send(in->sdi, &packet);

	inc->samples_in_buffer = 0;

	if (rc)
		return rc;

	return SR_OK;
}

/*
 * Add N copies of the current sample to the buffer. Send the buffer to
 * the session feed when a maximum amount of data was collected.
 */
static int add_samples(struct sr_input *in, uint64_t samples, size_t count)
{
	struct context *inc;
	uint8_t sample_buffer[sizeof(uint64_t)];
	size_t idx;
	size_t copy_count;
	uint8_t *p;
	int rc;

	inc = in->priv;
	for (idx = 0; idx < inc->unitsize; idx++) {
		sample_buffer[idx] = samples & 0xff;
		samples >>= 8;
	}
	while (count) {
		copy_count = inc->samples_per_chunk - inc->samples_in_buffer;
		if (copy_count > count)
			copy_count = count;
		count -= copy_count;

		p = inc->feed_buffer + inc->samples_in_buffer * inc->unitsize;
		while (copy_count-- > 0) {
			memcpy(p, sample_buffer, inc->unitsize);
			p += inc->unitsize;
			inc->samples_in_buffer++;
		}

		if (inc->samples_in_buffer == inc->samples_per_chunk) {
			rc = send_buffer(in);
			if (rc)
				return rc;
		}
	}

	return SR_OK;
}

/* Pass on previously received samples to the session. */
static int process_queued_samples(struct sr_input *in)
{
	struct context *inc;
	struct sample_data_entry *entry;
	uint64_t sample_bits;
	int rc;

	inc = in->priv;
	while (inc->sample_lines_fed < inc->sample_lines_total) {
		entry = &inc->sample_data_queue[inc->sample_lines_fed++];
		sample_bits = entry->bits;
		sample_bits ^= inc->wires_inverted;
		sample_bits &= inc->wires_enabled;
		rc = add_samples(in, sample_bits, entry->repeat);
		if (rc)
			return rc;
	}

	return SR_OK;
}

/*
 * Create required resources between having read the input file and
 * sending sample data to the session. Send initial packets before
 * sample data follows.
 */
static int prepare_session_feed(struct sr_input *in)
{
	struct context *inc;
	int rc;

	inc = in->priv;
	if (inc->ch_feed_prep)
		return SR_OK;

	/* Got channel names? At least fallbacks? */
	if (!inc->wire_names[0] || !inc->wire_names[0][0])
		return SR_ERR_DATA;
	/* Samples seen? Seen them all? */
	if (!inc->channel_count)
		return SR_ERR_DATA;
	if (!inc->sample_lines_total)
		return SR_ERR_DATA;
	if (inc->in_sample_data)
		return SR_ERR_DATA;
	if (!inc->sample_data_queue)
		return SR_ERR_DATA;
	inc->sample_lines_fed = 0;

	/*
	 * Normalize some variants of input data.
	 * - Let's create a mask for the maximum possible
	 *   bit positions, it will be useful to avoid garbage
	 *   in other code paths, too.
	 * - Input files _might_ specify which channels were
	 *   enabled during acquisition. _Or_ not specify the
	 *   enabled channels, but provide 'U' values in some
	 *   columns. When neither was seen, assume that all
	 *   channels are enabled.
	 * - If there are any signal groups, put all signals into
	 *   an anonymous group that are not part of another group.
	 */
	inc->wires_all_mask = 1UL << 0;
	inc->wires_all_mask <<= inc->channel_count;
	inc->wires_all_mask--;
	sr_dbg("all wires mask: 0x%" PRIx64 ".", inc->wires_all_mask);
	if (!inc->wires_enabled) {
		inc->wires_enabled = ~inc->wires_undefined;
		inc->wires_enabled &= ~inc->wires_all_mask;
		sr_dbg("enabled from undefined: 0x%" PRIx64 ".",
			inc->wires_enabled);
	}
	if (!inc->wires_enabled) {
		inc->wires_enabled = inc->wires_all_mask;
		sr_dbg("enabled from total mask: 0x%" PRIx64 ".",
			inc->wires_enabled);
	}
	sr_dbg("enabled mask: 0x%" PRIx64 ".",
		inc->wires_enabled);
	rc = process_ungrouped_signals(inc);
	if (rc)
		return rc;

	/*
	 * "Start" the session: Create channels, send the DF
	 * header to the session. Optionally send the sample
	 * rate before sample data will be sent.
	 */
	rc = create_channels_groups_buffer(in);
	if (rc)
		return rc;

	inc->ch_feed_prep = TRUE;

	return SR_OK;
}

static int format_match(GHashTable *metadata)
{
	GString *buf, *tmpbuf;
	int rc;
	gchar *version, *build;

	/* Get a copy of the start of the file's content. */
	buf = g_hash_table_lookup(metadata, GINT_TO_POINTER(SR_INPUT_META_HEADER));
	if (!buf || !buf->str)
		return SR_ERR_ARG;
	tmpbuf = g_string_new_len(buf->str, buf->len);
	if (!tmpbuf || !tmpbuf->str)
		return SR_ERR_MALLOC;

	/* See if we can spot a typical first LPF line. */
	rc = check_vers_line(tmpbuf->str, 1, &version, &build);
	if (rc == SR_OK && version && build) {
		sr_dbg("Looks like a LogicProbe project, version %s, build %s.",
			version, build);
	}
	g_string_free(tmpbuf, TRUE);

	return rc;
}

static int init(struct sr_input *in, GHashTable *options)
{
	struct context *inc;

	(void)options;

	in->sdi = g_malloc0(sizeof(*in->sdi));

	inc = g_malloc0(sizeof(*inc));
	if (!inc)
		return SR_ERR_MALLOC;
	in->priv = inc;

	return SR_OK;
}

static int receive(struct sr_input *in, GString *buf)
{
	struct context *inc;
	int rc;

	/* Accumulate another chunk of input data. */
	g_string_append_len(in->buf, buf->str, buf->len);

	/*
	 * Wait for the full header's availability, then process it in a
	 * single call, and set the "ready" flag. Make sure sample data
	 * and the header get processed in disjoint calls to receive(),
	 * the backend requires those separate phases.
	 */
	inc = in->priv;
	if (!inc->got_header) {
		if (!have_header(in->buf))
			return SR_OK;
		rc = parse_header(in);
		if (rc)
			return rc;
		rc = prepare_session_feed(in);
		if (rc)
			return rc;
		in->sdi_ready = TRUE;
		return SR_OK;
	}

	/* Process sample data, after the header got processed. */
	rc = process_queued_samples(in);

	return rc;
}

static int end(struct sr_input *in)
{
	struct context *inc;
	int rc;

	/* Nothing to do here if we never started feeding the session. */
	if (!in->sdi_ready)
		return SR_OK;

	/*
	 * Process sample data that may not have been forwarded before.
	 * Flush any potentially queued samples.
	 */
	rc = process_queued_samples(in);
	if (rc)
		return rc;
	rc = send_buffer(in);
	if (rc)
		return rc;

	/* End the session feed if one was started. */
	inc = in->priv;
	if (inc->header_sent) {
		rc = std_session_send_df_end(in->sdi);
		inc->header_sent = FALSE;
	}

	return rc;
}

static void cleanup(struct sr_input *in)
{
	struct context *inc;
	size_t idx;

	if (!in)
		return;

	inc = in->priv;
	if (!inc)
		return;

	/*
	 * Release potentially allocated resources. Void all references
	 * and scalars, so that re-runs start out fresh again.
	 */
	g_free(inc->sw_version);
	g_string_free(inc->cont_buff, TRUE);
	g_free(inc->sample_data_queue);
	for (idx = 0; idx < inc->channel_count; idx++)
		g_free(inc->wire_names[idx]);
	for (idx = 0; idx < inc->channel_count; idx++)
		g_free(inc->signal_names[idx]);
	g_slist_free_full(inc->signal_groups, sg_free);
	g_slist_free_full(inc->channels, g_free);
	g_free(inc->feed_buffer);
	memset(inc, 0, sizeof(*inc));
}

static int reset(struct sr_input *in)
{
	struct context *inc;

	inc = in->priv;
	cleanup(in);
	inc->ch_feed_prep = FALSE;
	inc->header_sent = FALSE;
	inc->rate_sent = FALSE;
	g_string_truncate(in->buf, 0);

	return SR_OK;
}

static struct sr_option options[] = {
	ALL_ZERO,
};

static const struct sr_option *get_options(void)
{
	return options;
}

SR_PRIV struct sr_input_module input_logicport = {
	.id = "logicport",
	.name = "LogicPort File",
	.desc = "Intronix LA1034 LogicPort project",
	.exts = (const char *[]){ "lpf", NULL },
	.metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
	.options = get_options,
	.format_match = format_match,
	.init = init,
	.receive = receive,
	.end = end,
	.cleanup = cleanup,
	.reset = reset,
};