[pulseview.git] / pv / data / signalbase.cpp

/*
 * This file is part of the PulseView project.
 *
 * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
 * Copyright (C) 2016 Soeren Apel <soeren@apelpie.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/>.
 */

#include "analog.hpp"
#include "analogsegment.hpp"
#include "decode/row.hpp"
#include "logic.hpp"
#include "logicsegment.hpp"
#include "signalbase.hpp"
#include "signaldata.hpp"

#include <pv/binding/decoder.hpp>
#include <pv/session.hpp>

using std::dynamic_pointer_cast;
using std::make_shared;
using std::shared_ptr;
using std::tie;

namespace pv {
namespace data {

const int SignalBase::ColourBGAlpha = 8 * 256 / 100;

SignalBase::SignalBase(shared_ptr<sigrok::Channel> channel, ChannelType channel_type) :
	channel_(channel),
	channel_type_(channel_type),
	conversion_type_(NoConversion)
{
	if (channel_)
		internal_name_ = QString::fromStdString(channel_->name());
}

SignalBase::~SignalBase()
{
	// Wait for the currently ongoing conversion to finish
	if (conversion_thread_.joinable())
		conversion_thread_.join();
}

shared_ptr<sigrok::Channel> SignalBase::channel() const
{
	return channel_;
}

QString SignalBase::name() const
{
	return (channel_) ? QString::fromStdString(channel_->name()) : name_;
}

QString SignalBase::internal_name() const
{
	return internal_name_;
}

void SignalBase::set_name(QString name)
{
	if (channel_)
		channel_->set_name(name.toUtf8().constData());

	name_ = name;

	name_changed(name);
}

bool SignalBase::enabled() const
{
	return (channel_) ? channel_->enabled() : true;
}

void SignalBase::set_enabled(bool value)
{
	if (channel_) {
		channel_->set_enabled(value);
		enabled_changed(value);
	}
}

SignalBase::ChannelType SignalBase::type() const
{
	return channel_type_;
}

unsigned int SignalBase::index() const
{
	return (channel_) ? channel_->index() : (unsigned int)-1;
}

QColor SignalBase::colour() const
{
	return colour_;
}

void SignalBase::set_colour(QColor colour)
{
	colour_ = colour;

	bgcolour_ = colour;
	bgcolour_.setAlpha(ColourBGAlpha);

	colour_changed(colour);
}

QColor SignalBase::bgcolour() const
{
	return bgcolour_;
}

void SignalBase::set_data(shared_ptr<pv::data::SignalData> data)
{
	if (data_) {
		disconnect(data.get(), SIGNAL(samples_cleared()),
			this, SLOT(on_samples_cleared()));
		disconnect(data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
			this, SLOT(on_samples_added(QObject*, uint64_t, uint64_t)));
	}

	data_ = data;

	if (data_) {
		connect(data.get(), SIGNAL(samples_cleared()),
			this, SLOT(on_samples_cleared()));
		connect(data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
			this, SLOT(on_samples_added(QObject*, uint64_t, uint64_t)));
	}
}

shared_ptr<data::Analog> SignalBase::analog_data() const
{
	shared_ptr<Analog> result = nullptr;

	if (channel_type_ == AnalogChannel)
		result = dynamic_pointer_cast<Analog>(data_);

	return result;
}

shared_ptr<data::Logic> SignalBase::logic_data() const
{
	shared_ptr<Logic> result = nullptr;

	if (channel_type_ == LogicChannel)
		result = dynamic_pointer_cast<Logic>(data_);

	if (((conversion_type_ == A2LConversionByTreshold) ||
		(conversion_type_ == A2LConversionBySchmittTrigger)))
		result = dynamic_pointer_cast<Logic>(converted_data_);

	return result;
}

void SignalBase::set_conversion_type(ConversionType t)
{
	if (conversion_type_ != NoConversion) {
		// Wait for the currently ongoing conversion to finish
		if (conversion_thread_.joinable())
			conversion_thread_.join();

		// Discard converted data
		converted_data_.reset();
	}

	conversion_type_ = t;

	if ((channel_type_ == AnalogChannel) &&
		((conversion_type_ == A2LConversionByTreshold) ||
		(conversion_type_ == A2LConversionBySchmittTrigger))) {

		shared_ptr<Analog> analog_data = dynamic_pointer_cast<Analog>(data_);

		if (analog_data->analog_segments().size() > 0) {
			AnalogSegment *asegment = analog_data->analog_segments().front().get();

			// Begin conversion of existing sample data
			// TODO Support for multiple segments is missing
			on_samples_added(asegment, 0, 0);
		}
	}

	conversion_type_changed(t);
}

#ifdef ENABLE_DECODE
bool SignalBase::is_decode_signal() const
{
	// DecodeSignal class overrides this method, all others shall return false
	return false;
}

shared_ptr<pv::data::DecoderStack> SignalBase::decoder_stack() const
{
	// DecodeSignal class overrides this method, all others shall return nothing
	return nullptr;
}
#endif

void SignalBase::save_settings(QSettings &settings) const
{
	settings.setValue("name", name());
	settings.setValue("enabled", enabled());
	settings.setValue("colour", colour());
	settings.setValue("conversion_type", (int)conversion_type_);
}

void SignalBase::restore_settings(QSettings &settings)
{
	set_name(settings.value("name").toString());
	set_enabled(settings.value("enabled").toBool());
	set_colour(settings.value("colour").value<QColor>());
	set_conversion_type((ConversionType)settings.value("conversion_type").toInt());
}

uint8_t SignalBase::convert_a2l_threshold(float threshold, float value)
{
	return (value >= threshold) ? 1 : 0;
}

uint8_t SignalBase::convert_a2l_schmitt_trigger(float lo_thr, float hi_thr,
	float value, uint8_t &state)
{
	if (value < lo_thr)
		state = 0;
	else if (value > hi_thr)
		state = 1;

	return state;
}

void SignalBase::conversion_thread_proc(QObject* segment, uint64_t start_sample,
	uint64_t end_sample)
{
	const uint64_t block_size = 4096;

	// TODO Support for multiple segments is missing

	if ((channel_type_ == AnalogChannel) &&
		((conversion_type_ == A2LConversionByTreshold) ||
		(conversion_type_ == A2LConversionBySchmittTrigger))) {

		AnalogSegment *asegment = qobject_cast<AnalogSegment*>(segment);

		// Create the logic data container if needed
		shared_ptr<Logic> logic_data;
		if (!converted_data_) {
			logic_data = make_shared<Logic>(1);  // Contains only one channel
			converted_data_ = logic_data;
		} else
			 logic_data = dynamic_pointer_cast<Logic>(converted_data_);

		// Create the initial logic data segment if needed
		if (logic_data->segments().size() == 0) {
			shared_ptr<LogicSegment> lsegment =
				make_shared<LogicSegment>(*logic_data.get(), 1, asegment->samplerate());
			logic_data->push_segment(lsegment);
		}

		LogicSegment *lsegment = dynamic_cast<LogicSegment*>(logic_data->segments().front().get());

		// start_sample=end_sample=0 means we need to figure out the unprocessed range
		if ((start_sample == 0) && (end_sample == 0)) {
			start_sample = lsegment->get_sample_count();
			end_sample = asegment->get_sample_count();
		}

		if (start_sample == end_sample)
			return;  // Nothing to do

		float min_v, max_v;
		tie(min_v, max_v) = asegment->get_min_max();

		vector<uint8_t> lsamples;
		lsamples.reserve(block_size);

		uint64_t i = start_sample;

		if (conversion_type_ == A2LConversionByTreshold) {
			const float threshold = (min_v + max_v) * 0.5;  // middle between min and max

			// Convert as many sample blocks as we can
			while ((end_sample - i) > block_size) {
				const float* asamples = asegment->get_samples(i, i + block_size);
				for (uint32_t j = 0; j < block_size; j++)
					lsamples.push_back(convert_a2l_threshold(threshold, asamples[j]));
				lsegment->append_payload(lsamples.data(), lsamples.size());
				i += block_size;
				lsamples.clear();
				delete[] asamples;
			}

			// Convert remaining samples
			const float* asamples = asegment->get_samples(i, end_sample);
			for (uint32_t j = 0; j < (end_sample - i); j++)
				lsamples.push_back(convert_a2l_threshold(threshold, asamples[j]));
			lsegment->append_payload(lsamples.data(), lsamples.size());
			delete[] asamples;

			samples_added(lsegment, start_sample, end_sample);
		}

		if (conversion_type_ == A2LConversionBySchmittTrigger) {
			const float amplitude = max_v - min_v;
			const float lo_thr = min_v + (amplitude * 0.1);  // 10% above min
			const float hi_thr = max_v - (amplitude * 0.1);  // 10% below max
			uint8_t state = 0;  // TODO Use value of logic sample n-1 instead of 0

			// Convert as many sample blocks as we can
			while ((end_sample - i) > block_size) {
				const float* asamples = asegment->get_samples(i, i + block_size);
				for (uint32_t j = 0; j < block_size; j++)
					lsamples.push_back(convert_a2l_schmitt_trigger(lo_thr, hi_thr, asamples[j], state));
				lsegment->append_payload(lsamples.data(), lsamples.size());
				i += block_size;
				lsamples.clear();
				delete[] asamples;
			}

			// Convert remaining samples
			const float* asamples = asegment->get_samples(i, end_sample);
			for (uint32_t j = 0; j < (end_sample - i); j++)
				lsamples.push_back(convert_a2l_schmitt_trigger(lo_thr, hi_thr, asamples[j], state));
			lsegment->append_payload(lsamples.data(), lsamples.size());
			delete[] asamples;

			samples_added(lsegment, start_sample, end_sample);
		}
	}
}

void SignalBase::on_samples_cleared()
{
	if (converted_data_)
		converted_data_->clear();

	samples_cleared();
}

void SignalBase::on_samples_added(QObject* segment, uint64_t start_sample,
	uint64_t end_sample)
{
	if (conversion_type_ != NoConversion) {

		// Wait for the currently ongoing conversion to finish
		if (conversion_thread_.joinable())
			conversion_thread_.join();

		conversion_thread_ = std::thread(
			&SignalBase::conversion_thread_proc, this,
			segment, start_sample, end_sample);
	}

	samples_added(segment, start_sample, end_sample);
}

void SignalBase::on_capture_state_changed(int state)
{
	return;
	if (state == Session::Stopped) {
		// Make sure that all data is converted

		if ((channel_type_ == AnalogChannel) &&
			((conversion_type_ == A2LConversionByTreshold) ||
			(conversion_type_ == A2LConversionBySchmittTrigger))) {

			shared_ptr<Analog> analog_data = dynamic_pointer_cast<Analog>(data_);

			if (analog_data->analog_segments().size() > 0) {
				// TODO Support for multiple segments is missing
				AnalogSegment *asegment = analog_data->analog_segments().front().get();

				if (conversion_thread_.joinable())
					conversion_thread_.join();

				conversion_thread_ = std::thread(
					&SignalBase::conversion_thread_proc, this, asegment, 0, 0);
			}
		}
	}
}

} // namespace data
} // namespace pv
Commit	Line	Data
bf0edd2b SA	1	/*
	2	* This file is part of the PulseView project.
	3	*
	4	* Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
	5	* Copyright (C) 2016 Soeren Apel <soeren@apelpie.net>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
efdec55a	18	* along with this program; if not, see <http://www.gnu.org/licenses/>.
bf0edd2b SA	19	*/
bf0edd2b SA	20
cbd2a2de	21	#include "analog.hpp"
12ea3616	22	#include "analogsegment.hpp"
aca9aa83	23	#include "decode/row.hpp"
cbd2a2de	24	#include "logic.hpp"
12ea3616	25	#include "logicsegment.hpp"
bf0edd2b	26	#include "signalbase.hpp"
cbd2a2de	27	#include "signaldata.hpp"
bb7dd726 SA	28
bb7dd726 SA	29	#include <pv/binding/decoder.hpp>
aca9aa83	30	#include <pv/session.hpp>
bf0edd2b	31
cbd2a2de	32	using std::dynamic_pointer_cast;
12ea3616	33	using std::make_shared;
bf0edd2b	34	using std::shared_ptr;
12ea3616	35	using std::tie;
bf0edd2b SA	36
	37	namespace pv {
	38	namespace data {
	39
c063290a	40	const int SignalBase::ColourBGAlpha = 8 * 256 / 100;
bf0edd2b	41
472a80c5 SA	42	SignalBase::SignalBase(shared_ptr<sigrok::Channel> channel, ChannelType channel_type) :
472a80c5 SA	43	channel_(channel),
12ea3616 SA	44	channel_type_(channel_type),
12ea3616 SA	45	conversion_type_(NoConversion)
bf0edd2b	46	{
050b5a6c SA	47	if (channel_)
050b5a6c SA	48	internal_name_ = QString::fromStdString(channel_->name());
bf0edd2b SA	49	}
bf0edd2b SA	50
12ea3616 SA	51	SignalBase::~SignalBase()
	52	{
	53	// Wait for the currently ongoing conversion to finish
	54	if (conversion_thread_.joinable())
	55	conversion_thread_.join();
	56	}
	57
bf0edd2b SA	58	shared_ptr<sigrok::Channel> SignalBase::channel() const
	59	{
	60	return channel_;
	61	}
	62
	63	QString SignalBase::name() const
	64	{
	65	return (channel_) ? QString::fromStdString(channel_->name()) : name_;
	66	}
	67
050b5a6c SA	68	QString SignalBase::internal_name() const
	69	{
	70	return internal_name_;
	71	}
	72
bf0edd2b SA	73	void SignalBase::set_name(QString name)
	74	{
	75	if (channel_)
	76	channel_->set_name(name.toUtf8().constData());
	77
	78	name_ = name;
	79
	80	name_changed(name);
	81	}
	82
	83	bool SignalBase::enabled() const
	84	{
	85	return (channel_) ? channel_->enabled() : true;
	86	}
	87
	88	void SignalBase::set_enabled(bool value)
	89	{
	90	if (channel_) {
	91	channel_->set_enabled(value);
	92	enabled_changed(value);
	93	}
	94	}
	95
472a80c5	96	SignalBase::ChannelType SignalBase::type() const
bf0edd2b	97	{
472a80c5	98	return channel_type_;
bf0edd2b SA	99	}
	100
	101	unsigned int SignalBase::index() const
	102	{
	103	return (channel_) ? channel_->index() : (unsigned int)-1;
	104	}
	105
	106	QColor SignalBase::colour() const
	107	{
	108	return colour_;
	109	}
	110
	111	void SignalBase::set_colour(QColor colour)
	112	{
	113	colour_ = colour;
	114
	115	bgcolour_ = colour;
	116	bgcolour_.setAlpha(ColourBGAlpha);
	117
	118	colour_changed(colour);
	119	}
	120
	121	QColor SignalBase::bgcolour() const
	122	{
	123	return bgcolour_;
	124	}
	125
cbd2a2de SA	126	void SignalBase::set_data(shared_ptr<pv::data::SignalData> data)
cbd2a2de SA	127	{
8ce8ebb9 SA	128	if (data_) {
8ce8ebb9 SA	129	disconnect(data.get(), SIGNAL(samples_cleared()),
12ea3616	130	this, SLOT(on_samples_cleared()));
8ce8ebb9	131	disconnect(data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
12ea3616 SA	132	this, SLOT(on_samples_added(QObject*, uint64_t, uint64_t)));
	133	}
	134
cbd2a2de	135	data_ = data;
12ea3616	136
8ce8ebb9 SA	137	if (data_) {
8ce8ebb9 SA	138	connect(data.get(), SIGNAL(samples_cleared()),
12ea3616	139	this, SLOT(on_samples_cleared()));
8ce8ebb9	140	connect(data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
12ea3616 SA	141	this, SLOT(on_samples_added(QObject*, uint64_t, uint64_t)));
12ea3616 SA	142	}
cbd2a2de SA	143	}
	144
	145	shared_ptr<data::Analog> SignalBase::analog_data() const
	146	{
12ea3616 SA	147	shared_ptr<Analog> result = nullptr;
12ea3616 SA	148
472a80c5	149	if (channel_type_ == AnalogChannel)
12ea3616 SA	150	result = dynamic_pointer_cast<Analog>(data_);
	151
	152	return result;
cbd2a2de SA	153	}
	154
	155	shared_ptr<data::Logic> SignalBase::logic_data() const
	156	{
12ea3616 SA	157	shared_ptr<Logic> result = nullptr;
12ea3616 SA	158
472a80c5	159	if (channel_type_ == LogicChannel)
12ea3616 SA	160	result = dynamic_pointer_cast<Logic>(data_);
	161
	162	if (((conversion_type_ == A2LConversionByTreshold) \|\|
	163	(conversion_type_ == A2LConversionBySchmittTrigger)))
	164	result = dynamic_pointer_cast<Logic>(converted_data_);
	165
	166	return result;
	167	}
	168
	169	void SignalBase::set_conversion_type(ConversionType t)
	170	{
	171	if (conversion_type_ != NoConversion) {
	172	// Wait for the currently ongoing conversion to finish
	173	if (conversion_thread_.joinable())
	174	conversion_thread_.join();
	175
	176	// Discard converted data
	177	converted_data_.reset();
	178	}
	179
	180	conversion_type_ = t;
	181
	182	if ((channel_type_ == AnalogChannel) &&
	183	((conversion_type_ == A2LConversionByTreshold) \|\|
	184	(conversion_type_ == A2LConversionBySchmittTrigger))) {
	185
	186	shared_ptr<Analog> analog_data = dynamic_pointer_cast<Analog>(data_);
	187
	188	if (analog_data->analog_segments().size() > 0) {
	189	AnalogSegment *asegment = analog_data->analog_segments().front().get();
	190
	191	// Begin conversion of existing sample data
	192	// TODO Support for multiple segments is missing
	193	on_samples_added(asegment, 0, 0);
	194	}
	195	}
	196
	197	conversion_type_changed(t);
cbd2a2de SA	198	}
cbd2a2de SA	199
bb7dd726 SA	200	#ifdef ENABLE_DECODE
	201	bool SignalBase::is_decode_signal() const
	202	{
ad908057 SA	203	// DecodeSignal class overrides this method, all others shall return false
ad908057 SA	204	return false;
bb7dd726 SA	205	}
bb7dd726 SA	206
6f925ba9	207	shared_ptr<pv::data::DecoderStack> SignalBase::decoder_stack() const
bb7dd726	208	{
ad908057 SA	209	// DecodeSignal class overrides this method, all others shall return nothing
ad908057 SA	210	return nullptr;
bb7dd726 SA	211	}
bb7dd726 SA	212	#endif
cbd2a2de	213
6de38b17 SA	214	void SignalBase::save_settings(QSettings &settings) const
	215	{
	216	settings.setValue("name", name());
	217	settings.setValue("enabled", enabled());
	218	settings.setValue("colour", colour());
12ea3616	219	settings.setValue("conversion_type", (int)conversion_type_);
6de38b17 SA	220	}
	221
	222	void SignalBase::restore_settings(QSettings &settings)
	223	{
	224	set_name(settings.value("name").toString());
	225	set_enabled(settings.value("enabled").toBool());
	226	set_colour(settings.value("colour").value<QColor>());
12ea3616 SA	227	set_conversion_type((ConversionType)settings.value("conversion_type").toInt());
	228	}
	229
	230	uint8_t SignalBase::convert_a2l_threshold(float threshold, float value)
	231	{
	232	return (value >= threshold) ? 1 : 0;
	233	}
	234
5d9fe823 SA	235	uint8_t SignalBase::convert_a2l_schmitt_trigger(float lo_thr, float hi_thr,
5d9fe823 SA	236	float value, uint8_t &state)
12ea3616	237	{
12ea3616 SA	238	if (value < lo_thr)
	239	state = 0;
	240	else if (value > hi_thr)
	241	state = 1;
	242
	243	return state;
	244	}
	245
	246	void SignalBase::conversion_thread_proc(QObject* segment, uint64_t start_sample,
	247	uint64_t end_sample)
	248	{
	249	const uint64_t block_size = 4096;
	250
	251	// TODO Support for multiple segments is missing
	252
	253	if ((channel_type_ == AnalogChannel) &&
	254	((conversion_type_ == A2LConversionByTreshold) \|\|
	255	(conversion_type_ == A2LConversionBySchmittTrigger))) {
	256
	257	AnalogSegment asegment = qobject_cast<AnalogSegment>(segment);
	258
	259	// Create the logic data container if needed
	260	shared_ptr<Logic> logic_data;
	261	if (!converted_data_) {
	262	logic_data = make_shared<Logic>(1); // Contains only one channel
	263	converted_data_ = logic_data;
	264	} else
	265	logic_data = dynamic_pointer_cast<Logic>(converted_data_);
	266
	267	// Create the initial logic data segment if needed
	268	if (logic_data->segments().size() == 0) {
	269	shared_ptr<LogicSegment> lsegment =
	270	make_shared<LogicSegment>(*logic_data.get(), 1, asegment->samplerate());
	271	logic_data->push_segment(lsegment);
	272	}
	273
	274	LogicSegment lsegment = dynamic_cast<LogicSegment>(logic_data->segments().front().get());
	275
	276	// start_sample=end_sample=0 means we need to figure out the unprocessed range
	277	if ((start_sample == 0) && (end_sample == 0)) {
	278	start_sample = lsegment->get_sample_count();
	279	end_sample = asegment->get_sample_count();
	280	}
	281
	282	if (start_sample == end_sample)
	283	return; // Nothing to do
	284
	285	float min_v, max_v;
	286	tie(min_v, max_v) = asegment->get_min_max();
	287
	288	vector<uint8_t> lsamples;
	289	lsamples.reserve(block_size);
	290
	291	uint64_t i = start_sample;
	292
	293	if (conversion_type_ == A2LConversionByTreshold) {
	294	const float threshold = (min_v + max_v) * 0.5; // middle between min and max
	295
	296	// Convert as many sample blocks as we can
	297	while ((end_sample - i) > block_size) {
	298	const float* asamples = asegment->get_samples(i, i + block_size);
	299	for (uint32_t j = 0; j < block_size; j++)
	300	lsamples.push_back(convert_a2l_threshold(threshold, asamples[j]));
	301	lsegment->append_payload(lsamples.data(), lsamples.size());
302	i += block_size;
303	lsamples.clear();
304	delete[] asamples;
305	}
306
307	// Convert remaining samples
308	const float* asamples = asegment->get_samples(i, end_sample);
309	for (uint32_t j = 0; j < (end_sample - i); j++)
310	lsamples.push_back(convert_a2l_threshold(threshold, asamples[j]));
311	lsegment->append_payload(lsamples.data(), lsamples.size());
312	delete[] asamples;
eae3bbbb SA	313
eae3bbbb SA	314	samples_added(lsegment, start_sample, end_sample);
12ea3616 SA	315	}
	316
	317	if (conversion_type_ == A2LConversionBySchmittTrigger) {
	318	const float amplitude = max_v - min_v;
	319	const float lo_thr = min_v + (amplitude * 0.1); // 10% above min
	320	const float hi_thr = max_v - (amplitude * 0.1); // 10% below max
5d9fe823	321	uint8_t state = 0; // TODO Use value of logic sample n-1 instead of 0
12ea3616 SA	322
	323	// Convert as many sample blocks as we can
	324	while ((end_sample - i) > block_size) {
	325	const float* asamples = asegment->get_samples(i, i + block_size);
	326	for (uint32_t j = 0; j < block_size; j++)
5d9fe823	327	lsamples.push_back(convert_a2l_schmitt_trigger(lo_thr, hi_thr, asamples[j], state));
12ea3616 SA	328	lsegment->append_payload(lsamples.data(), lsamples.size());
	329	i += block_size;
	330	lsamples.clear();
	331	delete[] asamples;
	332	}
	333
	334	// Convert remaining samples
	335	const float* asamples = asegment->get_samples(i, end_sample);
	336	for (uint32_t j = 0; j < (end_sample - i); j++)
5d9fe823	337	lsamples.push_back(convert_a2l_schmitt_trigger(lo_thr, hi_thr, asamples[j], state));
12ea3616 SA	338	lsegment->append_payload(lsamples.data(), lsamples.size());
12ea3616 SA	339	delete[] asamples;
eae3bbbb SA	340
eae3bbbb SA	341	samples_added(lsegment, start_sample, end_sample);
12ea3616 SA	342	}
	343	}
	344	}
	345
	346	void SignalBase::on_samples_cleared()
	347	{
	348	if (converted_data_)
	349	converted_data_->clear();
eae3bbbb SA	350
eae3bbbb SA	351	samples_cleared();
12ea3616 SA	352	}
	353
	354	void SignalBase::on_samples_added(QObject* segment, uint64_t start_sample,
	355	uint64_t end_sample)
	356	{
12ea3616 SA	357	if (conversion_type_ != NoConversion) {
	358
	359	// Wait for the currently ongoing conversion to finish
	360	if (conversion_thread_.joinable())
	361	conversion_thread_.join();
	362
	363	conversion_thread_ = std::thread(
	364	&SignalBase::conversion_thread_proc, this,
	365	segment, start_sample, end_sample);
	366	}
eae3bbbb SA	367
eae3bbbb SA	368	samples_added(segment, start_sample, end_sample);
12ea3616 SA	369	}
	370
	371	void SignalBase::on_capture_state_changed(int state)
	372	{
	373	return;
	374	if (state == Session::Stopped) {
	375	// Make sure that all data is converted
	376
	377	if ((channel_type_ == AnalogChannel) &&
	378	((conversion_type_ == A2LConversionByTreshold) \|\|
	379	(conversion_type_ == A2LConversionBySchmittTrigger))) {
	380
	381	shared_ptr<Analog> analog_data = dynamic_pointer_cast<Analog>(data_);
	382
	383	if (analog_data->analog_segments().size() > 0) {
	384	// TODO Support for multiple segments is missing
	385	AnalogSegment *asegment = analog_data->analog_segments().front().get();
	386
	387	if (conversion_thread_.joinable())
	388	conversion_thread_.join();
	389
	390	conversion_thread_ = std::thread(
	391	&SignalBase::conversion_thread_proc, this, asegment, 0, 0);
	392	}
	393	}
	394	}
6de38b17 SA	395	}
6de38b17 SA	396
bf0edd2b SA	397	} // namespace data
bf0edd2b SA	398	} // namespace pv