X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=bindings%2Fcxx%2Fclasses.cpp;h=d5477847653f85acb6f637b48de4a3ce677a9659;hp=eabe36a38654f65e7710f4cfeb10cfb6482ff165;hb=HEAD;hpb=0c697a4b339451514d4814974708816ce7858b8e

diff --git a/bindings/cxx/classes.cpp b/bindings/cxx/classes.cpp
index eabe36a3..d5477847 100644
--- a/bindings/cxx/classes.cpp
+++ b/bindings/cxx/classes.cpp
@@ -18,8 +18,9 @@
  */
 
 /* Needed for isascii(), as used in the GNU libstdc++ headers */
+/* Needed in strutil.c for POSIX.1-2008 locale functions */
 #ifndef _XOPEN_SOURCE
-#define _XOPEN_SOURCE 600
+#define _XOPEN_SOURCE 700
 #endif
 
 #include <config.h>
@@ -31,6 +32,8 @@
 namespace sigrok
 {
 
+using namespace std;
+
 /** Helper function to translate C errors to C++ exceptions. */
 static void check(int result)
 {
@@ -101,7 +104,7 @@ SR_PRIV int ResourceReader::close_callback(struct sr_resource *res,
 	return SR_OK;
 }
 
-SR_PRIV ssize_t ResourceReader::read_callback(const struct sr_resource *res,
+SR_PRIV gssize ResourceReader::read_callback(const struct sr_resource *res,
 		void *buf, size_t count, void *cb_data) noexcept
 {
 	try {
@@ -157,8 +160,7 @@ string Context::lib_version()
 map<string, shared_ptr<Driver>> Context::drivers()
 {
 	map<string, shared_ptr<Driver>> result;
-	for (const auto &entry: _drivers)
-	{
+	for (const auto &entry: _drivers) {
 		const auto &name = entry.first;
 		const auto &driver = entry.second;
 		result.emplace(name, driver->share_owned_by(shared_from_this()));
@@ -169,8 +171,7 @@ map<string, shared_ptr<Driver>> Context::drivers()
 map<string, shared_ptr<InputFormat>> Context::input_formats()
 {
 	map<string, shared_ptr<InputFormat>> result;
-	for (const auto &entry: _input_formats)
-	{
+	for (const auto &entry: _input_formats) {
 		const auto &name = entry.first;
 		const auto &input_format = entry.second;
 		result.emplace(name, input_format->share_owned_by(shared_from_this()));
@@ -178,11 +179,36 @@ map<string, shared_ptr<InputFormat>> Context::input_formats()
 	return result;
 }
 
+shared_ptr<InputFormat> Context::input_format_match(string filename)
+{
+	const struct sr_input *input;
+	const struct sr_input_module *imod;
+	int rc;
+
+	/*
+	 * Have the input module looked up for the specified file.
+	 * Failed lookup (or "successful lookup" with an empty result)
+	 * are non-fatal. Free the sr_input that was created by the
+	 * lookup routine, but grab the input module kind and return an
+	 * InputFormat instance to the application. This works because
+	 * the application passes a filename, no input data got buffered
+	 * in the sr_input that we release.
+	 */
+	input = NULL;
+	rc = sr_input_scan_file(filename.c_str(), &input);
+	if (rc != SR_OK)
+		return nullptr;
+	if (!input)
+		return nullptr;
+	imod = sr_input_module_get(input);
+	sr_input_free(input);
+	return shared_ptr<InputFormat>{new InputFormat{imod}, default_delete<InputFormat>{}};
+}
+
 map<string, shared_ptr<OutputFormat>> Context::output_formats()
 {
 	map<string, shared_ptr<OutputFormat>> result;
-	for (const auto &entry: _output_formats)
-	{
+	for (const auto &entry: _output_formats) {
 		const auto &name = entry.first;
 		const auto &output_format = entry.second;
 		result.emplace(name, output_format->share_owned_by(shared_from_this()));
@@ -213,12 +239,9 @@ static int call_log_callback(void *cb_data, int loglevel,
 
 	auto *const callback = static_cast<LogCallbackFunction *>(cb_data);
 
-	try
-	{
+	try {
 		(*callback)(LogLevel::get(loglevel), message.get());
-	}
-	catch (Error e)
-	{
+	} catch (Error &e) {
 		return e.result;
 	}
 
@@ -264,12 +287,12 @@ shared_ptr<UserDevice> Context::create_user_device(
 		default_delete<UserDevice>{}};
 }
 
-shared_ptr<Packet> Context::create_header_packet(Glib::TimeVal start_time)
+shared_ptr<Packet> Context::create_header_packet(Glib::DateTime start_time)
 {
 	auto header = g_new(struct sr_datafeed_header, 1);
 	header->feed_version = 1;
-	header->starttime.tv_sec = start_time.tv_sec;
-	header->starttime.tv_usec = start_time.tv_usec;
+	header->starttime.tv_sec = start_time.to_unix();
+	header->starttime.tv_usec = start_time.get_microsecond();
 	auto packet = g_new(struct sr_datafeed_packet, 1);
 	packet->type = SR_DF_HEADER;
 	packet->payload = header;
@@ -281,8 +304,7 @@ shared_ptr<Packet> Context::create_meta_packet(
 	map<const ConfigKey *, Glib::VariantBase> config)
 {
 	auto meta = g_new0(struct sr_datafeed_meta, 1);
-	for (const auto &input : config)
-	{
+	for (const auto &input : config) {
 		const auto &key = input.first;
 		const auto &value = input.second;
 		auto *const output = g_new(struct sr_config, 1);
@@ -312,27 +334,59 @@ shared_ptr<Packet> Context::create_logic_packet(
 
 shared_ptr<Packet> Context::create_analog_packet(
 	vector<shared_ptr<Channel> > channels,
-	float *data_pointer, unsigned int num_samples, const Quantity *mq,
+	const float *data_pointer, unsigned int num_samples, const Quantity *mq,
 	const Unit *unit, vector<const QuantityFlag *> mqflags)
 {
 	auto analog = g_new0(struct sr_datafeed_analog, 1);
 	auto meaning = g_new0(struct sr_analog_meaning, 1);
+	auto encoding = g_new0(struct sr_analog_encoding, 1);
+	auto spec = g_new0(struct sr_analog_spec, 1);
 
 	analog->meaning = meaning;
 
 	for (const auto &channel : channels)
 		meaning->channels = g_slist_append(meaning->channels, channel->_structure);
-	analog->num_samples = num_samples;
 	meaning->mq = static_cast<sr_mq>(mq->id());
 	meaning->unit = static_cast<sr_unit>(unit->id());
 	meaning->mqflags = static_cast<sr_mqflag>(QuantityFlag::mask_from_flags(move(mqflags)));
-	analog->data = data_pointer;
+
+	analog->encoding = encoding;
+
+	encoding->unitsize = sizeof(float);
+	encoding->is_signed = TRUE;
+	encoding->is_float = TRUE;
+#ifdef WORDS_BIGENDIAN
+	encoding->is_bigendian = TRUE;
+#else
+	encoding->is_bigendian = FALSE;
+#endif
+	encoding->digits = 0;
+	encoding->is_digits_decimal = FALSE;
+	encoding->scale.p = 1;
+	encoding->scale.q = 1;
+	encoding->offset.p = 0;
+	encoding->offset.q = 1;
+
+	analog->spec = spec;
+
+	spec->spec_digits = 0;
+
+	analog->num_samples = num_samples;
+	analog->data = (float*)data_pointer;
 	auto packet = g_new(struct sr_datafeed_packet, 1);
 	packet->type = SR_DF_ANALOG;
 	packet->payload = analog;
 	return shared_ptr<Packet>{new Packet{nullptr, packet}, default_delete<Packet>{}};
 }
 
+shared_ptr<Packet> Context::create_end_packet()
+{
+	auto packet = g_new(struct sr_datafeed_packet, 1);
+	packet->type = SR_DF_END;
+	return shared_ptr<Packet>{new Packet{nullptr, packet},
+		default_delete<Packet>{}};
+}
+
 shared_ptr<Session> Context::load_session(string filename)
 {
 	return shared_ptr<Session>{
@@ -408,11 +462,13 @@ string Driver::long_name() const
 
 set<const ConfigKey *> Driver::scan_options() const
 {
-	GArray *opts = sr_driver_scan_options(_structure);
+	GArray *opts = sr_driver_scan_options_list(_structure);
 	set<const ConfigKey *> result;
-	for (guint i = 0; i < opts->len; i++)
-		result.insert(ConfigKey::get(g_array_index(opts, uint32_t, i)));
-	g_array_free(opts, TRUE);
+	if (opts) {
+		for (guint i = 0; i < opts->len; i++)
+			result.insert(ConfigKey::get(g_array_index(opts, uint32_t, i)));
+		g_array_free(opts, TRUE);
+	}
 	return result;
 }
 
@@ -420,16 +476,14 @@ vector<shared_ptr<HardwareDevice>> Driver::scan(
 	map<const ConfigKey *, Glib::VariantBase> options)
 {
 	/* Initialise the driver if not yet done. */
-	if (!_initialized)
-	{
+	if (!_initialized) {
 		check(sr_driver_init(_parent->_structure, _structure));
 		_initialized = true;
 	}
 
 	/* Translate scan options to GSList of struct sr_config pointers. */
 	GSList *option_list = nullptr;
-	for (const auto &entry : options)
-	{
+	for (const auto &entry : options) {
 		const auto &key = entry.first;
 		const auto &value = entry.second;
 		auto *const config = g_new(struct sr_config, 1);
@@ -447,8 +501,7 @@ vector<shared_ptr<HardwareDevice>> Driver::scan(
 
 	/* Create device objects. */
 	vector<shared_ptr<HardwareDevice>> result;
-	for (GSList *device = device_list; device; device = device->next)
-	{
+	for (GSList *device = device_list; device; device = device->next) {
 		auto *const sdi = static_cast<struct sr_dev_inst *>(device->data);
 		shared_ptr<HardwareDevice> hwdev {
 			new HardwareDevice{shared_from_this(), sdi},
@@ -483,10 +536,11 @@ set<const ConfigKey *> Configurable::config_keys() const
 
 	opts = sr_dev_options(config_driver, config_sdi, config_channel_group);
 
-	for (guint i = 0; i < opts->len; i++)
-		result.insert(ConfigKey::get(g_array_index(opts, uint32_t, i)));
-
-	g_array_free(opts, TRUE);
+	if (opts) {
+		for (guint i = 0; i < opts->len; i++)
+			result.insert(ConfigKey::get(g_array_index(opts, uint32_t, i)));
+		g_array_free(opts, TRUE);
+	}
 
 	return result;
 }
@@ -543,15 +597,13 @@ Device::Device(struct sr_dev_inst *structure) :
 	Configurable(sr_dev_inst_driver_get(structure), structure, nullptr),
 	_structure(structure)
 {
-	for (GSList *entry = sr_dev_inst_channels_get(structure); entry; entry = entry->next)
-	{
+	for (GSList *entry = sr_dev_inst_channels_get(structure); entry; entry = entry->next) {
 		auto *const ch = static_cast<struct sr_channel *>(entry->data);
 		unique_ptr<Channel> channel {new Channel{ch}};
 		_channels.emplace(ch, move(channel));
 	}
 
-	for (GSList *entry = sr_dev_inst_channel_groups_get(structure); entry; entry = entry->next)
-	{
+	for (GSList *entry = sr_dev_inst_channel_groups_get(structure); entry; entry = entry->next) {
 		auto *const cg = static_cast<struct sr_channel_group *>(entry->data);
 		unique_ptr<ChannelGroup> group {new ChannelGroup{this, cg}};
 		_channel_groups.emplace(group->name(), move(group));
@@ -559,7 +611,8 @@ Device::Device(struct sr_dev_inst *structure) :
 }
 
 Device::~Device()
-{}
+{
+}
 
 string Device::vendor() const
 {
@@ -605,8 +658,7 @@ map<string, shared_ptr<ChannelGroup>>
 Device::channel_groups()
 {
 	map<string, shared_ptr<ChannelGroup>> result;
-	for (const auto &entry: _channel_groups)
-	{
+	for (const auto &entry: _channel_groups) {
 		const auto &name = entry.first;
 		const auto &channel_group = entry.second;
 		result.emplace(name, channel_group->share_owned_by(get_shared_from_this()));
@@ -741,7 +793,7 @@ vector<shared_ptr<Channel>> ChannelGroup::channels()
 	return result;
 }
 
-Trigger::Trigger(shared_ptr<Context> context, string name) : 
+Trigger::Trigger(shared_ptr<Context> context, string name) :
 	_structure(sr_trigger_new(name.c_str())),
 	_context(move(context))
 {
@@ -785,7 +837,7 @@ TriggerStage::TriggerStage(struct sr_trigger_stage *structure) :
 TriggerStage::~TriggerStage()
 {
 }
-	
+
 int TriggerStage::number() const
 {
 	return _structure->stage;
@@ -894,6 +946,7 @@ Session::Session(shared_ptr<Context> context, string filename) :
 		_owned_devices.emplace(sdi, move(device));
 	}
 	_context->_session = this;
+	g_slist_free(dev_list);
 }
 
 Session::~Session()
@@ -928,6 +981,7 @@ vector<shared_ptr<Device>> Session::devices()
 		auto *const sdi = static_cast<struct sr_dev_inst *>(dev->data);
 		result.push_back(get_device(sdi));
 	}
+	g_slist_free(dev_list);
 	return result;
 }
 
@@ -1100,11 +1154,10 @@ int Header::feed_version() const
 	return _structure->feed_version;
 }
 
-Glib::TimeVal Header::start_time() const
+Glib::DateTime Header::start_time() const
 {
-	return Glib::TimeVal(
-		_structure->starttime.tv_sec,
-		_structure->starttime.tv_usec);
+	Glib::DateTime time = Glib::DateTime::create_now_utc(_structure->starttime.tv_sec);
+	return time.add_seconds(_structure->starttime.tv_usec / 1.0e6);
 }
 
 Meta::Meta(const struct sr_datafeed_meta *structure) :
@@ -1185,6 +1238,11 @@ void *Analog::data_pointer()
 	return _structure->data;
 }
 
+void Analog::get_data_as_float(float *dest)
+{
+	check(sr_analog_to_float(_structure, dest));
+}
+
 unsigned int Analog::num_samples() const
 {
 	return _structure->num_samples;
@@ -1200,6 +1258,58 @@ vector<shared_ptr<Channel>> Analog::channels()
 	return result;
 }
 
+unsigned int Analog::unitsize() const
+{
+	return _structure->encoding->unitsize;
+}
+
+bool Analog::is_signed() const
+{
+	return _structure->encoding->is_signed;
+}
+
+bool Analog::is_float() const
+{
+	return _structure->encoding->is_float;
+}
+
+bool Analog::is_bigendian() const
+{
+	return _structure->encoding->is_bigendian;
+}
+
+int Analog::digits() const
+{
+	return _structure->encoding->digits;
+}
+
+bool Analog::is_digits_decimal() const
+{
+	return _structure->encoding->is_digits_decimal;
+}
+
+shared_ptr<Rational> Analog::scale()
+{
+	unique_ptr<Rational> scale;
+	scale.reset(new Rational(&(_structure->encoding->scale)));
+
+	if (scale)
+		return scale->share_owned_by(shared_from_this());
+	else
+		throw Error(SR_ERR_NA);
+}
+
+shared_ptr<Rational> Analog::offset()
+{
+	unique_ptr<Rational> offset;
+	offset.reset(new Rational(&(_structure->encoding->offset)));
+
+	if (offset)
+		return offset->share_owned_by(shared_from_this());
+	else
+		throw Error(SR_ERR_NA);
+}
+
 const Quantity *Analog::mq() const
 {
 	return Quantity::get(_structure->meaning->mq);
@@ -1215,6 +1325,78 @@ vector<const QuantityFlag *> Analog::mq_flags() const
 	return QuantityFlag::flags_from_mask(_structure->meaning->mqflags);
 }
 
+shared_ptr<Logic> Analog::get_logic_via_threshold(float threshold,
+	uint8_t *data_ptr) const
+{
+	auto datafeed = g_new(struct sr_datafeed_logic, 1);
+	datafeed->length = num_samples();
+	datafeed->unitsize = 1;
+
+	if (data_ptr)
+		datafeed->data = data_ptr;
+	else
+		datafeed->data = g_malloc(datafeed->length);
+
+	shared_ptr<Logic> logic =
+		shared_ptr<Logic>{new Logic{datafeed}, default_delete<Logic>{}};
+
+	check(sr_a2l_threshold(_structure, threshold,
+		(uint8_t*)datafeed->data, datafeed->length));
+
+	return logic;
+}
+
+shared_ptr<Logic> Analog::get_logic_via_schmitt_trigger(float lo_thr,
+	float hi_thr, uint8_t *state, uint8_t *data_ptr) const
+{
+	auto datafeed = g_new(struct sr_datafeed_logic, 1);
+	datafeed->length = num_samples();
+	datafeed->unitsize = 1;
+
+	if (data_ptr)
+		datafeed->data = data_ptr;
+	else
+		datafeed->data = g_malloc(datafeed->length);
+
+	shared_ptr<Logic> logic =
+		shared_ptr<Logic>{new Logic{datafeed}, default_delete<Logic>{}};
+
+	check(sr_a2l_schmitt_trigger(_structure, lo_thr, hi_thr, state,
+		(uint8_t*)datafeed->data, datafeed->length));
+
+	return logic;
+}
+
+Rational::Rational(const struct sr_rational *structure) :
+	_structure(structure)
+{
+}
+
+Rational::~Rational()
+{
+}
+
+shared_ptr<Rational> Rational::share_owned_by(shared_ptr<Analog> _parent)
+{
+	return static_pointer_cast<Rational>(
+		ParentOwned::share_owned_by(_parent));
+}
+
+int64_t Rational::numerator() const
+{
+	return _structure->p;
+}
+
+uint64_t Rational::denominator() const
+{
+	return _structure->q;
+}
+
+float Rational::value() const
+{
+	return (float)(_structure->p) / (float)(_structure->q);
+}
+
 InputFormat::InputFormat(const struct sr_input_module *structure) :
 	_structure(structure)
 {
@@ -1247,8 +1429,7 @@ map<string, shared_ptr<Option>> InputFormat::options()
 {
 	map<string, shared_ptr<Option>> result;
 
-	if (const struct sr_option **options = sr_input_options_get(_structure))
-	{
+	if (const struct sr_option **options = sr_input_options_get(_structure)) {
 		shared_ptr<const struct sr_option *> option_array
 			{options, &sr_input_options_free};
 		for (int i = 0; options[i]; i++) {
@@ -1278,8 +1459,7 @@ Input::Input(shared_ptr<Context> context, const struct sr_input *structure) :
 
 shared_ptr<InputDevice> Input::device()
 {
-	if (!_device)
-	{
+	if (!_device) {
 		auto sdi = sr_input_dev_inst_get(_structure);
 		if (!sdi)
 			throw Error(SR_ERR_NA);
@@ -1293,7 +1473,7 @@ void Input::send(void *data, size_t length)
 {
 	auto gstr = g_string_new_len(static_cast<char *>(data), length);
 	auto ret = sr_input_send(_structure, gstr);
-	g_string_free(gstr, false);
+	g_string_free(gstr, true);
 	check(ret);
 }
 
@@ -1302,6 +1482,11 @@ void Input::end()
 	check(sr_input_end(_structure));
 }
 
+void Input::reset()
+{
+	check(sr_input_reset(_structure));
+}
+
 Input::~Input()
 {
 	sr_input_free(_structure);
@@ -1364,6 +1549,30 @@ vector<Glib::VariantBase> Option::values() const
 	return result;
 }
 
+Glib::VariantBase Option::parse_string(string value)
+{
+	enum sr_datatype dt;
+	Glib::VariantBase dflt = default_value();
+	GVariant *tmpl = dflt.gobj();
+
+	if (g_variant_is_of_type(tmpl, G_VARIANT_TYPE_UINT64)) {
+		dt = SR_T_UINT64;
+	} else if (g_variant_is_of_type(tmpl, G_VARIANT_TYPE_STRING)) {
+		dt = SR_T_STRING;
+	} else if (g_variant_is_of_type(tmpl, G_VARIANT_TYPE_BOOLEAN)) {
+		dt = SR_T_BOOL;
+	} else if (g_variant_is_of_type(tmpl, G_VARIANT_TYPE_DOUBLE)) {
+		dt = SR_T_FLOAT;
+	} else if (g_variant_is_of_type(tmpl, G_VARIANT_TYPE_INT32)) {
+		dt = SR_T_INT32;
+	} else if (g_variant_is_of_type(tmpl, G_VARIANT_TYPE_UINT32)) {
+		dt = SR_T_UINT32;
+	} else {
+		throw Error(SR_ERR_BUG);
+	}
+	return ConfigKey::parse_string(value, dt);
+}
+
 OutputFormat::OutputFormat(const struct sr_output_module *structure) :
 	_structure(structure)
 {
@@ -1396,8 +1605,7 @@ map<string, shared_ptr<Option>> OutputFormat::options()
 {
 	map<string, shared_ptr<Option>> result;
 
-	if (const struct sr_option **options = sr_output_options_get(_structure))
-	{
+	if (const struct sr_option **options = sr_output_options_get(_structure)) {
 		shared_ptr<const struct sr_option *> option_array
 			{options, &sr_output_options_free};
 		for (int i = 0; options[i]; i++) {
@@ -1456,18 +1664,20 @@ Output::~Output()
 	check(sr_output_free(_structure));
 }
 
+shared_ptr<OutputFormat> Output::format()
+{
+	return _format;
+}
+
 string Output::receive(shared_ptr<Packet> packet)
 {
 	GString *out;
 	check(sr_output_send(_structure, packet->_structure, &out));
-	if (out)
-	{
+	if (out) {
 		auto result = string(out->str, out->str + out->len);
 		g_string_free(out, true);
 		return result;
-	}
-	else
-	{
+	} else {
 		return string();
 	}
 }