[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;
using std::unique_lock;

namespace pv {
namespace data {

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

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()
{
	stop_conversion();
}

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() : 0;
}

unsigned int SignalBase::logic_bit_index() const
{
	if (channel_type_ == LogicChannel)
		return channel_->index();
	else
		return 0;
}

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) {
		stop_conversion();

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

	conversion_type_ = t;

	// Re-create an empty container
	// so that the signal is recognized as providing logic data
	// and thus can be assigned to a decoder
	if (conversion_is_a2l())
		if (!converted_data_)
			converted_data_ = make_shared<Logic>(1);  // Contains only one channel

	start_conversion();

	conversion_type_changed(t);
}

#ifdef ENABLE_DECODE
bool SignalBase::is_decode_signal() const
{
	return (channel_type_ == DecodeChannel);
}
#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());
}

bool SignalBase::conversion_is_a2l() const
{
	return ((channel_type_ == AnalogChannel) &&
		((conversion_type_ == A2LConversionByTreshold) ||
		(conversion_type_ == A2LConversionBySchmittTrigger)));
}

void SignalBase::conversion_thread_proc(QObject* segment)
{
	// TODO Support for multiple segments is missing

	uint64_t start_sample, end_sample;
	start_sample = end_sample = 0;

	do {
		if (conversion_is_a2l()) {

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

			const shared_ptr<Logic> 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 = lsegment->get_sample_count();
			end_sample = asegment->get_sample_count();

			if (end_sample > start_sample) {
				float min_v, max_v;
				tie(min_v, max_v) = asegment->get_min_max();

				// Create sigrok::Analog instance
				float *asamples = new float[ConversionBlockSize];
				uint8_t *lsamples = new uint8_t[ConversionBlockSize];

				vector<shared_ptr<sigrok::Channel> > channels;
				channels.push_back(channel_);

				vector<const sigrok::QuantityFlag*> mq_flags;
				const sigrok::Quantity * const mq = sigrok::Quantity::VOLTAGE;
				const sigrok::Unit * const unit = sigrok::Unit::VOLT;

				shared_ptr<sigrok::Packet> packet =
					Session::sr_context->create_analog_packet(channels,
					asamples, ConversionBlockSize, mq, unit, mq_flags);

				shared_ptr<sigrok::Analog> analog =
					dynamic_pointer_cast<sigrok::Analog>(packet->payload());

				// Convert
				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) > ConversionBlockSize) {
						asegment->get_samples(i, i + ConversionBlockSize, asamples);

						shared_ptr<sigrok::Logic> logic =
							analog->get_logic_via_threshold(threshold, lsamples);

						lsegment->append_payload(logic->data_pointer(), logic->data_length());

						samples_added(lsegment, i, i + ConversionBlockSize);
						i += ConversionBlockSize;
					}

					// Re-create sigrok::Analog and convert remaining samples
					packet = Session::sr_context->create_analog_packet(channels,
						asamples, end_sample - i, mq, unit, mq_flags);

					analog = dynamic_pointer_cast<sigrok::Analog>(packet->payload());

					asegment->get_samples(i, end_sample, asamples);
					shared_ptr<sigrok::Logic> logic =
						analog->get_logic_via_threshold(threshold, lsamples);
					lsegment->append_payload(logic->data_pointer(), logic->data_length());
					samples_added(lsegment, i, end_sample);
				}

				if (conversion_type_ == A2LConversionBySchmittTrigger) {
					const float amplitude = max_v - min_v;
					const float center = min_v + (amplitude / 2);
					const float lo_thr = center - (amplitude * 0.15); // 15% margin
					const float hi_thr = center + (amplitude * 0.15); // 15% margin
					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) > ConversionBlockSize) {
						asegment->get_samples(i, i + ConversionBlockSize, asamples);

						shared_ptr<sigrok::Logic> logic =
							analog->get_logic_via_schmitt_trigger(lo_thr, hi_thr,
								&state, lsamples);

						lsegment->append_payload(logic->data_pointer(), logic->data_length());

						samples_added(lsegment, i, i + ConversionBlockSize);
						i += ConversionBlockSize;
					}

					// Re-create sigrok::Analog and convert remaining samples
					packet = Session::sr_context->create_analog_packet(channels,
						asamples, end_sample - i, mq, unit, mq_flags);

					analog = dynamic_pointer_cast<sigrok::Analog>(packet->payload());

					asegment->get_samples(i, end_sample, asamples);
					shared_ptr<sigrok::Logic> logic =
						analog->get_logic_via_schmitt_trigger(lo_thr, hi_thr,
							&state, lsamples);
					lsegment->append_payload(logic->data_pointer(), logic->data_length());
					samples_added(lsegment, i, end_sample);
				}

				// If acquisition is ongoing, start-/endsample may have changed
				end_sample = asegment->get_sample_count();

				delete[] lsamples;
				delete[] asamples;
			}
		}

		if (!conversion_interrupt_ && (start_sample == end_sample)) {
			unique_lock<mutex> input_lock(conversion_input_mutex_);
			conversion_input_cond_.wait(input_lock);
		}
	} while (!conversion_interrupt_);
}

void SignalBase::start_conversion()
{
	stop_conversion();

	if (conversion_is_a2l()) {
		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();

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

void SignalBase::stop_conversion()
{
	// Stop conversion so we can restart it from the beginning
	conversion_interrupt_ = true;
	conversion_input_cond_.notify_one();
	if (conversion_thread_.joinable())
		conversion_thread_.join();
}

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) {
		if (conversion_thread_.joinable()) {
			// Notify the conversion thread since it's running
			conversion_input_cond_.notify_one();
		} else {
			// Start the conversion thread
			start_conversion();
		}
	}

	samples_added(segment, start_sample, end_sample);
}

void SignalBase::on_capture_state_changed(int state)
{
	if (state == Session::Running) {
		if (conversion_type_ != NoConversion) {
			// Restart conversion
			stop_conversion();
			start_conversion();
		}
	}
}

} // namespace data
} // namespace pv
Commit	Line	Data
	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
	18	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include "analog.hpp"
	22	#include "analogsegment.hpp"
	23	#include "decode/row.hpp"
	24	#include "logic.hpp"
	25	#include "logicsegment.hpp"
	26	#include "signalbase.hpp"
	27	#include "signaldata.hpp"
	28
	29	#include <pv/binding/decoder.hpp>
	30	#include <pv/session.hpp>
	31
	32	using std::dynamic_pointer_cast;
	33	using std::make_shared;
	34	using std::shared_ptr;
	35	using std::tie;
	36	using std::unique_lock;
	37
	38	namespace pv {
	39	namespace data {
	40
	41	const int SignalBase::ColourBGAlpha = 8 * 256 / 100;
	42	const uint64_t SignalBase::ConversionBlockSize = 4096;
	43
	44	SignalBase::SignalBase(shared_ptr<sigrok::Channel> channel, ChannelType channel_type) :
	45	channel_(channel),
	46	channel_type_(channel_type),
	47	conversion_type_(NoConversion)
	48	{
	49	if (channel_)
	50	internal_name_ = QString::fromStdString(channel_->name());
	51	}
	52
	53	SignalBase::~SignalBase()
	54	{
	55	stop_conversion();
	56	}
	57
	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
	68	QString SignalBase::internal_name() const
	69	{
	70	return internal_name_;
	71	}
	72
	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
	96	SignalBase::ChannelType SignalBase::type() const
	97	{
	98	return channel_type_;
	99	}
	100
	101	unsigned int SignalBase::index() const
	102	{
	103	return (channel_) ? channel_->index() : 0;
	104	}
	105
	106	unsigned int SignalBase::logic_bit_index() const
	107	{
	108	if (channel_type_ == LogicChannel)
	109	return channel_->index();
	110	else
	111	return 0;
	112	}
	113
	114	QColor SignalBase::colour() const
	115	{
	116	return colour_;
	117	}
	118
	119	void SignalBase::set_colour(QColor colour)
	120	{
	121	colour_ = colour;
	122
	123	bgcolour_ = colour;
	124	bgcolour_.setAlpha(ColourBGAlpha);
	125
	126	colour_changed(colour);
	127	}
	128
	129	QColor SignalBase::bgcolour() const
	130	{
	131	return bgcolour_;
	132	}
	133
	134	void SignalBase::set_data(shared_ptr<pv::data::SignalData> data)
	135	{
	136	if (data_) {
	137	disconnect(data.get(), SIGNAL(samples_cleared()),
	138	this, SLOT(on_samples_cleared()));
	139	disconnect(data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
	140	this, SLOT(on_samples_added(QObject*, uint64_t, uint64_t)));
	141	}
	142
	143	data_ = data;
	144
	145	if (data_) {
	146	connect(data.get(), SIGNAL(samples_cleared()),
	147	this, SLOT(on_samples_cleared()));
	148	connect(data.get(), SIGNAL(samples_added(QObject*, uint64_t, uint64_t)),
	149	this, SLOT(on_samples_added(QObject*, uint64_t, uint64_t)));
	150	}
	151	}
	152
	153	shared_ptr<data::Analog> SignalBase::analog_data() const
	154	{
	155	shared_ptr<Analog> result = nullptr;
	156
	157	if (channel_type_ == AnalogChannel)
	158	result = dynamic_pointer_cast<Analog>(data_);
	159
	160	return result;
	161	}
	162
	163	shared_ptr<data::Logic> SignalBase::logic_data() const
	164	{
	165	shared_ptr<Logic> result = nullptr;
	166
	167	if (channel_type_ == LogicChannel)
	168	result = dynamic_pointer_cast<Logic>(data_);
	169
	170	if (((conversion_type_ == A2LConversionByTreshold) \|\|
	171	(conversion_type_ == A2LConversionBySchmittTrigger)))
	172	result = dynamic_pointer_cast<Logic>(converted_data_);
	173
	174	return result;
	175	}
	176
	177	void SignalBase::set_conversion_type(ConversionType t)
	178	{
	179	if (conversion_type_ != NoConversion) {
	180	stop_conversion();
	181
	182	// Discard converted data
	183	converted_data_.reset();
	184	samples_cleared();
	185	}
	186
	187	conversion_type_ = t;
	188
	189	// Re-create an empty container
	190	// so that the signal is recognized as providing logic data
	191	// and thus can be assigned to a decoder
	192	if (conversion_is_a2l())
	193	if (!converted_data_)
	194	converted_data_ = make_shared<Logic>(1); // Contains only one channel
	195
	196	start_conversion();
	197
	198	conversion_type_changed(t);
	199	}
	200
	201	#ifdef ENABLE_DECODE
	202	bool SignalBase::is_decode_signal() const
	203	{
	204	return (channel_type_ == DecodeChannel);
	205	}
	206	#endif
	207
	208	void SignalBase::save_settings(QSettings &settings) const
	209	{
	210	settings.setValue("name", name());
	211	settings.setValue("enabled", enabled());
	212	settings.setValue("colour", colour());
	213	settings.setValue("conversion_type", (int)conversion_type_);
	214	}
	215
	216	void SignalBase::restore_settings(QSettings &settings)
	217	{
	218	set_name(settings.value("name").toString());
	219	set_enabled(settings.value("enabled").toBool());
	220	set_colour(settings.value("colour").value<QColor>());
	221	set_conversion_type((ConversionType)settings.value("conversion_type").toInt());
	222	}
	223
	224	bool SignalBase::conversion_is_a2l() const
	225	{
	226	return ((channel_type_ == AnalogChannel) &&
	227	((conversion_type_ == A2LConversionByTreshold) \|\|
	228	(conversion_type_ == A2LConversionBySchmittTrigger)));
	229	}
	230
	231	void SignalBase::conversion_thread_proc(QObject* segment)
	232	{
	233	// TODO Support for multiple segments is missing
	234
	235	uint64_t start_sample, end_sample;
	236	start_sample = end_sample = 0;
	237
	238	do {
	239	if (conversion_is_a2l()) {
	240
	241	AnalogSegment asegment = qobject_cast<AnalogSegment>(segment);
	242
	243	const shared_ptr<Logic> logic_data = dynamic_pointer_cast<Logic>(converted_data_);
	244
	245	// Create the initial logic data segment if needed
	246	if (logic_data->segments().size() == 0) {
	247	shared_ptr<LogicSegment> lsegment =
	248	make_shared<LogicSegment>(*logic_data.get(), 1, asegment->samplerate());
	249	logic_data->push_segment(lsegment);
	250	}
	251
	252	LogicSegment lsegment = dynamic_cast<LogicSegment>(logic_data->segments().front().get());
	253
	254	start_sample = lsegment->get_sample_count();
	255	end_sample = asegment->get_sample_count();
	256
	257	if (end_sample > start_sample) {
	258	float min_v, max_v;
	259	tie(min_v, max_v) = asegment->get_min_max();
	260
	261	// Create sigrok::Analog instance
	262	float *asamples = new float[ConversionBlockSize];
	263	uint8_t *lsamples = new uint8_t[ConversionBlockSize];
	264
	265	vector<shared_ptr<sigrok::Channel> > channels;
	266	channels.push_back(channel_);
	267
	268	vector<const sigrok::QuantityFlag*> mq_flags;
	269	const sigrok::Quantity * const mq = sigrok::Quantity::VOLTAGE;
	270	const sigrok::Unit * const unit = sigrok::Unit::VOLT;
	271
	272	shared_ptr<sigrok::Packet> packet =
	273	Session::sr_context->create_analog_packet(channels,
	274	asamples, ConversionBlockSize, mq, unit, mq_flags);
	275
	276	shared_ptr<sigrok::Analog> analog =
	277	dynamic_pointer_cast<sigrok::Analog>(packet->payload());
	278
	279	// Convert
	280	uint64_t i = start_sample;
	281
	282	if (conversion_type_ == A2LConversionByTreshold) {
	283	const float threshold = (min_v + max_v) * 0.5; // middle between min and max
	284
	285	// Convert as many sample blocks as we can
	286	while ((end_sample - i) > ConversionBlockSize) {
	287	asegment->get_samples(i, i + ConversionBlockSize, asamples);
	288
	289	shared_ptr<sigrok::Logic> logic =
	290	analog->get_logic_via_threshold(threshold, lsamples);
	291
	292	lsegment->append_payload(logic->data_pointer(), logic->data_length());
	293
	294	samples_added(lsegment, i, i + ConversionBlockSize);
	295	i += ConversionBlockSize;
	296	}
	297
	298	// Re-create sigrok::Analog and convert remaining samples
	299	packet = Session::sr_context->create_analog_packet(channels,
	300	asamples, end_sample - i, mq, unit, mq_flags);
	301
	302	analog = dynamic_pointer_cast<sigrok::Analog>(packet->payload());
	303
	304	asegment->get_samples(i, end_sample, asamples);
	305	shared_ptr<sigrok::Logic> logic =
	306	analog->get_logic_via_threshold(threshold, lsamples);
	307	lsegment->append_payload(logic->data_pointer(), logic->data_length());
	308	samples_added(lsegment, i, end_sample);
	309	}
	310
	311	if (conversion_type_ == A2LConversionBySchmittTrigger) {
	312	const float amplitude = max_v - min_v;
	313	const float center = min_v + (amplitude / 2);
	314	const float lo_thr = center - (amplitude * 0.15); // 15% margin
	315	const float hi_thr = center + (amplitude * 0.15); // 15% margin
	316	uint8_t state = 0; // TODO Use value of logic sample n-1 instead of 0
	317
	318	// Convert as many sample blocks as we can
	319	while ((end_sample - i) > ConversionBlockSize) {
	320	asegment->get_samples(i, i + ConversionBlockSize, asamples);
	321
	322	shared_ptr<sigrok::Logic> logic =
	323	analog->get_logic_via_schmitt_trigger(lo_thr, hi_thr,
	324	&state, lsamples);
	325
	326	lsegment->append_payload(logic->data_pointer(), logic->data_length());
	327
	328	samples_added(lsegment, i, i + ConversionBlockSize);
	329	i += ConversionBlockSize;
	330	}
	331
	332	// Re-create sigrok::Analog and convert remaining samples
	333	packet = Session::sr_context->create_analog_packet(channels,
	334	asamples, end_sample - i, mq, unit, mq_flags);
	335
	336	analog = dynamic_pointer_cast<sigrok::Analog>(packet->payload());
	337
	338	asegment->get_samples(i, end_sample, asamples);
	339	shared_ptr<sigrok::Logic> logic =
	340	analog->get_logic_via_schmitt_trigger(lo_thr, hi_thr,
	341	&state, lsamples);
	342	lsegment->append_payload(logic->data_pointer(), logic->data_length());
	343	samples_added(lsegment, i, end_sample);
	344	}
	345
	346	// If acquisition is ongoing, start-/endsample may have changed
	347	end_sample = asegment->get_sample_count();
	348
	349	delete[] lsamples;
	350	delete[] asamples;
	351	}
	352	}
	353
	354	if (!conversion_interrupt_ && (start_sample == end_sample)) {
	355	unique_lock<mutex> input_lock(conversion_input_mutex_);
	356	conversion_input_cond_.wait(input_lock);
	357	}
	358	} while (!conversion_interrupt_);
	359	}
	360
	361	void SignalBase::start_conversion()
	362	{
	363	stop_conversion();
	364
	365	if (conversion_is_a2l()) {
	366	shared_ptr<Analog> analog_data = dynamic_pointer_cast<Analog>(data_);
	367
	368	if (analog_data->analog_segments().size() > 0) {
	369	// TODO Support for multiple segments is missing
	370	AnalogSegment *asegment = analog_data->analog_segments().front().get();
	371
	372	conversion_interrupt_ = false;
	373	conversion_thread_ = std::thread(
	374	&SignalBase::conversion_thread_proc, this, asegment);
	375	}
	376	}
	377	}
	378
	379	void SignalBase::stop_conversion()
	380	{
	381	// Stop conversion so we can restart it from the beginning
	382	conversion_interrupt_ = true;
	383	conversion_input_cond_.notify_one();
	384	if (conversion_thread_.joinable())
	385	conversion_thread_.join();
	386	}
	387
	388	void SignalBase::on_samples_cleared()
	389	{
	390	if (converted_data_)
	391	converted_data_->clear();
	392
	393	samples_cleared();
	394	}
	395
	396	void SignalBase::on_samples_added(QObject* segment, uint64_t start_sample,
	397	uint64_t end_sample)
	398	{
	399	if (conversion_type_ != NoConversion) {
	400	if (conversion_thread_.joinable()) {
	401	// Notify the conversion thread since it's running
	402	conversion_input_cond_.notify_one();
	403	} else {
	404	// Start the conversion thread
	405	start_conversion();
	406	}
	407	}
	408
	409	samples_added(segment, start_sample, end_sample);
	410	}
	411
	412	void SignalBase::on_capture_state_changed(int state)
	413	{
	414	if (state == Session::Running) {
	415	if (conversion_type_ != NoConversion) {
	416	// Restart conversion
	417	stop_conversion();
	418	start_conversion();
	419	}
	420	}
	421	}
	422
	423	} // namespace data
	424	} // namespace pv