[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
{
	return (decoder_stack_ != nullptr);
}

shared_ptr<pv::data::DecoderStack> SignalBase::decoder_stack() const
{
	return decoder_stack_;
}

void SignalBase::set_decoder_stack(shared_ptr<pv::data::DecoderStack>
	decoder_stack)
{
	decoder_stack_ = decoder_stack;
}
#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	{
	203	return (decoder_stack_ != nullptr);
	204	}
	205
6f925ba9	206	shared_ptr<pv::data::DecoderStack> SignalBase::decoder_stack() const
bb7dd726 SA	207	{
	208	return decoder_stack_;
	209	}
	210
6f925ba9	211	void SignalBase::set_decoder_stack(shared_ptr<pv::data::DecoderStack>
bb7dd726 SA	212	decoder_stack)
	213	{
	214	decoder_stack_ = decoder_stack;
	215	}
	216	#endif
cbd2a2de	217
6de38b17 SA	218	void SignalBase::save_settings(QSettings &settings) const
	219	{
	220	settings.setValue("name", name());
	221	settings.setValue("enabled", enabled());
	222	settings.setValue("colour", colour());
12ea3616	223	settings.setValue("conversion_type", (int)conversion_type_);
6de38b17 SA	224	}
	225
	226	void SignalBase::restore_settings(QSettings &settings)
	227	{
	228	set_name(settings.value("name").toString());
	229	set_enabled(settings.value("enabled").toBool());
	230	set_colour(settings.value("colour").value<QColor>());
12ea3616 SA	231	set_conversion_type((ConversionType)settings.value("conversion_type").toInt());
	232	}
	233
	234	uint8_t SignalBase::convert_a2l_threshold(float threshold, float value)
	235	{
	236	return (value >= threshold) ? 1 : 0;
	237	}
	238
5d9fe823 SA	239	uint8_t SignalBase::convert_a2l_schmitt_trigger(float lo_thr, float hi_thr,
5d9fe823 SA	240	float value, uint8_t &state)
12ea3616	241	{
12ea3616 SA	242	if (value < lo_thr)
	243	state = 0;
	244	else if (value > hi_thr)
	245	state = 1;
	246
	247	return state;
	248	}
	249
	250	void SignalBase::conversion_thread_proc(QObject* segment, uint64_t start_sample,
	251	uint64_t end_sample)
	252	{
	253	const uint64_t block_size = 4096;
	254
	255	// TODO Support for multiple segments is missing
	256
	257	if ((channel_type_ == AnalogChannel) &&
	258	((conversion_type_ == A2LConversionByTreshold) \|\|
	259	(conversion_type_ == A2LConversionBySchmittTrigger))) {
	260
	261	AnalogSegment asegment = qobject_cast<AnalogSegment>(segment);
	262
	263	// Create the logic data container if needed
	264	shared_ptr<Logic> logic_data;
	265	if (!converted_data_) {
	266	logic_data = make_shared<Logic>(1); // Contains only one channel
	267	converted_data_ = logic_data;
	268	} else
	269	logic_data = dynamic_pointer_cast<Logic>(converted_data_);
	270
	271	// Create the initial logic data segment if needed
	272	if (logic_data->segments().size() == 0) {
	273	shared_ptr<LogicSegment> lsegment =
	274	make_shared<LogicSegment>(*logic_data.get(), 1, asegment->samplerate());
	275	logic_data->push_segment(lsegment);
	276	}
	277
	278	LogicSegment lsegment = dynamic_cast<LogicSegment>(logic_data->segments().front().get());
	279
	280	// start_sample=end_sample=0 means we need to figure out the unprocessed range
	281	if ((start_sample == 0) && (end_sample == 0)) {
	282	start_sample = lsegment->get_sample_count();
	283	end_sample = asegment->get_sample_count();
	284	}
	285
	286	if (start_sample == end_sample)
	287	return; // Nothing to do
	288
	289	float min_v, max_v;
	290	tie(min_v, max_v) = asegment->get_min_max();
	291
	292	vector<uint8_t> lsamples;
	293	lsamples.reserve(block_size);
	294
	295	uint64_t i = start_sample;
	296
	297	if (conversion_type_ == A2LConversionByTreshold) {
	298	const float threshold = (min_v + max_v) * 0.5; // middle between min and max
	299
	300	// Convert as many sample blocks as we can
	301	while ((end_sample - i) > block_size) {
	302	const float* asamples = asegment->get_samples(i, i + block_size);
	303	for (uint32_t j = 0; j < block_size; j++)
	304	lsamples.push_back(convert_a2l_threshold(threshold, asamples[j]));
	305	lsegment->append_payload(lsamples.data(), lsamples.size());
306	i += block_size;
307	lsamples.clear();
308	delete[] asamples;
309	}
310
311	// Convert remaining samples
312	const float* asamples = asegment->get_samples(i, end_sample);
313	for (uint32_t j = 0; j < (end_sample - i); j++)
314	lsamples.push_back(convert_a2l_threshold(threshold, asamples[j]));
315	lsegment->append_payload(lsamples.data(), lsamples.size());
316	delete[] asamples;
eae3bbbb SA	317
eae3bbbb SA	318	samples_added(lsegment, start_sample, end_sample);
12ea3616 SA	319	}
	320
	321	if (conversion_type_ == A2LConversionBySchmittTrigger) {
	322	const float amplitude = max_v - min_v;
	323	const float lo_thr = min_v + (amplitude * 0.1); // 10% above min
	324	const float hi_thr = max_v - (amplitude * 0.1); // 10% below max
5d9fe823	325	uint8_t state = 0; // TODO Use value of logic sample n-1 instead of 0
12ea3616 SA	326
	327	// Convert as many sample blocks as we can
	328	while ((end_sample - i) > block_size) {
	329	const float* asamples = asegment->get_samples(i, i + block_size);
	330	for (uint32_t j = 0; j < block_size; j++)
5d9fe823	331	lsamples.push_back(convert_a2l_schmitt_trigger(lo_thr, hi_thr, asamples[j], state));
12ea3616 SA	332	lsegment->append_payload(lsamples.data(), lsamples.size());
	333	i += block_size;
	334	lsamples.clear();
	335	delete[] asamples;
	336	}
	337
	338	// Convert remaining samples
	339	const float* asamples = asegment->get_samples(i, end_sample);
	340	for (uint32_t j = 0; j < (end_sample - i); j++)
5d9fe823	341	lsamples.push_back(convert_a2l_schmitt_trigger(lo_thr, hi_thr, asamples[j], state));
12ea3616 SA	342	lsegment->append_payload(lsamples.data(), lsamples.size());
12ea3616 SA	343	delete[] asamples;
eae3bbbb SA	344
eae3bbbb SA	345	samples_added(lsegment, start_sample, end_sample);
12ea3616 SA	346	}
	347	}
	348	}
	349
	350	void SignalBase::on_samples_cleared()
	351	{
	352	if (converted_data_)
	353	converted_data_->clear();
eae3bbbb SA	354
eae3bbbb SA	355	samples_cleared();
12ea3616 SA	356	}
	357
	358	void SignalBase::on_samples_added(QObject* segment, uint64_t start_sample,
	359	uint64_t end_sample)
	360	{
12ea3616 SA	361	if (conversion_type_ != NoConversion) {
	362
	363	// Wait for the currently ongoing conversion to finish
	364	if (conversion_thread_.joinable())
	365	conversion_thread_.join();
	366
	367	conversion_thread_ = std::thread(
	368	&SignalBase::conversion_thread_proc, this,
	369	segment, start_sample, end_sample);
	370	}
eae3bbbb SA	371
eae3bbbb SA	372	samples_added(segment, start_sample, end_sample);
12ea3616 SA	373	}
	374
	375	void SignalBase::on_capture_state_changed(int state)
	376	{
	377	return;
	378	if (state == Session::Stopped) {
	379	// Make sure that all data is converted
	380
	381	if ((channel_type_ == AnalogChannel) &&
	382	((conversion_type_ == A2LConversionByTreshold) \|\|
	383	(conversion_type_ == A2LConversionBySchmittTrigger))) {
	384
	385	shared_ptr<Analog> analog_data = dynamic_pointer_cast<Analog>(data_);
	386
	387	if (analog_data->analog_segments().size() > 0) {
	388	// TODO Support for multiple segments is missing
	389	AnalogSegment *asegment = analog_data->analog_segments().front().get();
	390
	391	if (conversion_thread_.joinable())
	392	conversion_thread_.join();
	393
	394	conversion_thread_ = std::thread(
	395	&SignalBase::conversion_thread_proc, this, asegment, 0, 0);
	396	}
	397	}
	398	}
6de38b17 SA	399	}
6de38b17 SA	400
bf0edd2b SA	401	} // namespace data
bf0edd2b SA	402	} // namespace pv