2 * This file is part of the libsigrok project.
4 * Copyright (C) 2013-2014 Martin Ling <martin-sigrok@earth.li>
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 /* Needed for isascii(), as used in the GNU libstdc++ headers */
22 #define _XOPEN_SOURCE 600
26 #include <libsigrokcxx/libsigrokcxx.hpp>
34 /** Helper function to translate C errors to C++ exceptions. */
35 static void check(int result)
41 /** Helper function to obtain valid strings from possibly null input. */
42 static const char *valid_string(const char *input)
50 /** Helper function to convert between map<string, VariantBase> and GHashTable */
51 static GHashTable *map_to_hash_variant(const map<string, Glib::VariantBase> &input)
53 auto output = g_hash_table_new_full(
54 g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
55 for (auto entry : input)
56 g_hash_table_insert(output,
57 g_strdup(entry.first.c_str()),
58 entry.second.gobj_copy());
62 Error::Error(int result) : result(result)
66 const char *Error::what() const throw()
68 return sr_strerror(result);
71 Error::~Error() throw()
75 ResourceReader::~ResourceReader()
79 SR_PRIV int ResourceReader::open_callback(struct sr_resource *res,
80 const char *name, void *cb_data)
83 auto *const reader = static_cast<ResourceReader*>(cb_data);
84 reader->open(res, name);
85 } catch (const Error &err) {
93 SR_PRIV int ResourceReader::close_callback(struct sr_resource *res, void *cb_data)
96 auto *const reader = static_cast<ResourceReader*>(cb_data);
98 } catch (const Error &err) {
106 SR_PRIV ssize_t ResourceReader::read_callback(const struct sr_resource *res,
107 void *buf, size_t count, void *cb_data)
110 auto *const reader = static_cast<ResourceReader*>(cb_data);
111 return reader->read(res, buf, count);
112 } catch (const Error &err) {
119 shared_ptr<Context> Context::create()
121 return shared_ptr<Context>(new Context(), Context::Deleter());
125 UserOwned(_structure),
128 check(sr_init(&_structure));
130 struct sr_dev_driver **driver_list = sr_driver_list(_structure);
132 for (int i = 0; driver_list[i]; i++)
133 _drivers[driver_list[i]->name] =
134 new Driver(driver_list[i]);
135 const struct sr_input_module **input_list = sr_input_list();
137 for (int i = 0; input_list[i]; i++)
138 _input_formats[sr_input_id_get(input_list[i])] =
139 new InputFormat(input_list[i]);
140 const struct sr_output_module **output_list = sr_output_list();
142 for (int i = 0; output_list[i]; i++)
143 _output_formats[sr_output_id_get(output_list[i])] =
144 new OutputFormat(output_list[i]);
147 string Context::package_version()
149 return sr_package_version_string_get();
152 string Context::lib_version()
154 return sr_lib_version_string_get();
157 map<string, shared_ptr<Driver>> Context::drivers()
159 map<string, shared_ptr<Driver>> result;
160 for (auto entry: _drivers)
162 auto name = entry.first;
163 auto driver = entry.second;
164 result[name] = driver->get_shared_pointer(this);
169 map<string, shared_ptr<InputFormat>> Context::input_formats()
171 map<string, shared_ptr<InputFormat>> result;
172 for (auto entry: _input_formats)
174 auto name = entry.first;
175 auto input_format = entry.second;
176 result[name] = input_format->get_shared_pointer(this);
181 map<string, shared_ptr<OutputFormat>> Context::output_formats()
183 map<string, shared_ptr<OutputFormat>> result;
184 for (auto entry: _output_formats)
186 auto name = entry.first;
187 auto output_format = entry.second;
188 result[name] = output_format->get_shared_pointer(this);
195 for (auto entry : _drivers)
197 for (auto entry : _input_formats)
199 for (auto entry : _output_formats)
201 check(sr_exit(_structure));
204 const LogLevel *Context::log_level()
206 return LogLevel::get(sr_log_loglevel_get());
209 void Context::set_log_level(const LogLevel *level)
211 check(sr_log_loglevel_set(level->id()));
214 static int call_log_callback(void *cb_data, int loglevel, const char *format, va_list args)
217 va_copy(args_copy, args);
218 int length = vsnprintf(NULL, 0, format, args_copy);
220 char *buf = (char *) g_malloc(length + 1);
221 vsprintf(buf, format, args);
222 string message(buf, length);
225 LogCallbackFunction callback = *((LogCallbackFunction *) cb_data);
229 callback(LogLevel::get(loglevel), message);
239 void Context::set_log_callback(LogCallbackFunction callback)
241 _log_callback = move(callback);
242 check(sr_log_callback_set(call_log_callback, &_log_callback));
245 void Context::set_log_callback_default()
247 check(sr_log_callback_set_default());
248 _log_callback = nullptr;
251 void Context::set_resource_reader(ResourceReader *reader)
254 check(sr_resource_set_hooks(_structure,
255 &ResourceReader::open_callback,
256 &ResourceReader::close_callback,
257 &ResourceReader::read_callback, reader));
259 check(sr_resource_set_hooks(_structure,
260 nullptr, nullptr, nullptr, nullptr));
264 shared_ptr<Session> Context::create_session()
266 return shared_ptr<Session>(
267 new Session(shared_from_this()), Session::Deleter());
270 shared_ptr<UserDevice> Context::create_user_device(
271 string vendor, string model, string version)
273 return shared_ptr<UserDevice>(
274 new UserDevice(vendor, model, version), UserDevice::Deleter());
277 shared_ptr<Packet> Context::create_header_packet(Glib::TimeVal start_time)
279 auto header = g_new(struct sr_datafeed_header, 1);
280 header->feed_version = 1;
281 header->starttime.tv_sec = start_time.tv_sec;
282 header->starttime.tv_usec = start_time.tv_usec;
283 auto packet = g_new(struct sr_datafeed_packet, 1);
284 packet->type = SR_DF_HEADER;
285 packet->payload = header;
286 return shared_ptr<Packet>(new Packet(nullptr, packet), Packet::Deleter());
289 shared_ptr<Packet> Context::create_meta_packet(
290 const map<const ConfigKey *, Glib::VariantBase> &config)
292 auto meta = g_new0(struct sr_datafeed_meta, 1);
293 for (auto input : config)
295 auto key = input.first;
296 auto value = input.second;
297 auto output = g_new(struct sr_config, 1);
298 output->key = key->id();
299 output->data = value.gobj();
300 g_variant_ref(output->data);
301 meta->config = g_slist_append(meta->config, output);
303 auto packet = g_new(struct sr_datafeed_packet, 1);
304 packet->type = SR_DF_META;
305 packet->payload = meta;
306 return shared_ptr<Packet>(new Packet(nullptr, packet), Packet::Deleter());
309 shared_ptr<Packet> Context::create_logic_packet(
310 void *data_pointer, size_t data_length, unsigned int unit_size)
312 auto logic = g_new(struct sr_datafeed_logic, 1);
313 logic->length = data_length;
314 logic->unitsize = unit_size;
315 logic->data = data_pointer;
316 auto packet = g_new(struct sr_datafeed_packet, 1);
317 packet->type = SR_DF_LOGIC;
318 packet->payload = logic;
319 return shared_ptr<Packet>(new Packet(nullptr, packet), Packet::Deleter());
322 shared_ptr<Packet> Context::create_analog_packet(
323 const vector<shared_ptr<Channel> > &channels,
324 float *data_pointer, unsigned int num_samples, const Quantity *mq,
325 const Unit *unit, const vector<const QuantityFlag *> &mqflags)
327 auto analog = g_new0(struct sr_datafeed_analog, 1);
328 auto meaning = g_new0(struct sr_analog_meaning, 1);
330 analog->meaning = meaning;
332 for (auto channel : channels)
333 meaning->channels = g_slist_append(meaning->channels, channel->_structure);
334 analog->num_samples = num_samples;
335 meaning->mq = (sr_mq)mq->id();
336 meaning->unit = (sr_unit)unit->id();
337 meaning->mqflags = (sr_mqflag)QuantityFlag::mask_from_flags(mqflags);
338 analog->data = data_pointer;
339 auto packet = g_new(struct sr_datafeed_packet, 1);
340 packet->type = SR_DF_ANALOG;
341 packet->payload = analog;
342 return shared_ptr<Packet>(new Packet(nullptr, packet), Packet::Deleter());
345 shared_ptr<Session> Context::load_session(string filename)
347 return shared_ptr<Session>(
348 new Session(shared_from_this(), move(filename)), Session::Deleter());
351 shared_ptr<Trigger> Context::create_trigger(string name)
353 return shared_ptr<Trigger>(
354 new Trigger(shared_from_this(), move(name)), Trigger::Deleter());
357 shared_ptr<Input> Context::open_file(string filename)
359 const struct sr_input *input;
361 check(sr_input_scan_file(filename.c_str(), &input));
362 return shared_ptr<Input>(
363 new Input(shared_from_this(), input), Input::Deleter());
366 shared_ptr<Input> Context::open_stream(string header)
368 const struct sr_input *input;
370 auto gstr = g_string_new(header.c_str());
371 auto ret = sr_input_scan_buffer(gstr, &input);
372 g_string_free(gstr, true);
374 return shared_ptr<Input>(
375 new Input(shared_from_this(), input), Input::Deleter());
378 map<string, string> Context::serials(shared_ptr<Driver> driver)
380 GSList *serial_list = sr_serial_list(driver ? driver->_structure : NULL);
381 map<string, string> serials;
383 for (GSList *serial = serial_list; serial; serial = serial->next) {
384 struct sr_serial_port *port = (sr_serial_port *) serial->data;
385 serials[string(port->name)] = string(port->description);
388 g_slist_free_full(serial_list, (GDestroyNotify)sr_serial_free);
392 Driver::Driver(struct sr_dev_driver *structure) :
393 ParentOwned(structure),
394 Configurable(structure, NULL, NULL),
403 string Driver::name()
405 return valid_string(_structure->name);
408 string Driver::long_name()
410 return valid_string(_structure->longname);
413 vector<shared_ptr<HardwareDevice>> Driver::scan(
414 const map<const ConfigKey *, Glib::VariantBase> &options)
416 /* Initialise the driver if not yet done. */
419 check(sr_driver_init(_parent->_structure, _structure));
423 /* Translate scan options to GSList of struct sr_config pointers. */
424 GSList *option_list = NULL;
425 for (auto entry : options)
427 auto key = entry.first;
428 auto value = entry.second;
429 auto config = g_new(struct sr_config, 1);
430 config->key = key->id();
431 config->data = value.gobj();
432 option_list = g_slist_append(option_list, config);
436 GSList *device_list = sr_driver_scan(_structure, option_list);
438 /* Free option list. */
439 g_slist_free_full(option_list, g_free);
442 /* Create device objects. */
443 vector<shared_ptr<HardwareDevice>> result;
444 for (GSList *device = device_list; device; device = device->next)
446 auto sdi = (struct sr_dev_inst *) device->data;
447 result.push_back(shared_ptr<HardwareDevice>(
448 new HardwareDevice(shared_from_this(), sdi),
449 HardwareDevice::Deleter()));
452 /* Free GSList returned from scan. */
453 g_slist_free(device_list);
458 Configurable::Configurable(
459 struct sr_dev_driver *driver,
460 struct sr_dev_inst *sdi,
461 struct sr_channel_group *cg) :
462 config_driver(driver),
464 config_channel_group(cg)
468 Configurable::~Configurable()
472 Glib::VariantBase Configurable::config_get(const ConfigKey *key)
476 config_driver, config_sdi, config_channel_group,
478 return Glib::VariantBase(data);
481 void Configurable::config_set(const ConfigKey *key, const Glib::VariantBase &value)
484 config_sdi, config_channel_group,
485 key->id(), const_cast<GVariant*>(value.gobj())));
488 Glib::VariantContainerBase Configurable::config_list(const ConfigKey *key)
491 check(sr_config_list(
492 config_driver, config_sdi, config_channel_group,
494 return Glib::VariantContainerBase(data);
497 map<const ConfigKey *, set<Capability>> Configurable::config_keys(const ConfigKey *key)
501 const uint32_t *opts;
502 map<const ConfigKey *, set<Capability>> result;
504 check(sr_config_list(
505 config_driver, config_sdi, config_channel_group,
506 key->id(), &gvar_opts));
508 opts = (const uint32_t *) g_variant_get_fixed_array(
509 gvar_opts, &num_opts, sizeof(uint32_t));
511 for (gsize i = 0; i < num_opts; i++)
513 auto key = ConfigKey::get(opts[i] & SR_CONF_MASK);
514 set<Capability> capabilities;
515 if (opts[i] & SR_CONF_GET)
516 capabilities.insert(GET);
517 if (opts[i] & SR_CONF_SET)
518 capabilities.insert(SET);
519 if (opts[i] & SR_CONF_LIST)
520 capabilities.insert(LIST);
521 result[key] = capabilities;
524 g_variant_unref(gvar_opts);
529 bool Configurable::config_check(const ConfigKey *key,
530 const ConfigKey *index_key)
534 const uint32_t *opts;
536 if (sr_config_list(config_driver, config_sdi, config_channel_group,
537 index_key->id(), &gvar_opts) != SR_OK)
540 opts = (const uint32_t *) g_variant_get_fixed_array(
541 gvar_opts, &num_opts, sizeof(uint32_t));
543 for (gsize i = 0; i < num_opts; i++)
545 if ((opts[i] & SR_CONF_MASK) == (uint32_t) key->id())
547 g_variant_unref(gvar_opts);
552 g_variant_unref(gvar_opts);
557 Device::Device(struct sr_dev_inst *structure) :
558 Configurable(sr_dev_inst_driver_get(structure), structure, NULL),
559 _structure(structure)
561 for (GSList *entry = sr_dev_inst_channels_get(structure); entry; entry = entry->next)
563 auto channel = (struct sr_channel *) entry->data;
564 _channels[channel] = new Channel(channel);
567 for (GSList *entry = sr_dev_inst_channel_groups_get(structure); entry; entry = entry->next)
569 auto group = (struct sr_channel_group *) entry->data;
570 _channel_groups[group->name] = new ChannelGroup(this, group);
576 for (auto entry : _channels)
578 for (auto entry : _channel_groups)
582 string Device::vendor()
584 return valid_string(sr_dev_inst_vendor_get(_structure));
587 string Device::model()
589 return valid_string(sr_dev_inst_model_get(_structure));
592 string Device::version()
594 return valid_string(sr_dev_inst_version_get(_structure));
597 string Device::serial_number()
599 return valid_string(sr_dev_inst_sernum_get(_structure));
602 string Device::connection_id()
604 return valid_string(sr_dev_inst_connid_get(_structure));
607 vector<shared_ptr<Channel>> Device::channels()
609 vector<shared_ptr<Channel>> result;
610 for (auto channel = sr_dev_inst_channels_get(_structure); channel; channel = channel->next)
612 _channels[(struct sr_channel *) channel->data]->get_shared_pointer(
613 get_shared_from_this()));
617 shared_ptr<Channel> Device::get_channel(struct sr_channel *ptr)
619 return _channels[ptr]->get_shared_pointer(get_shared_from_this());
622 map<string, shared_ptr<ChannelGroup>>
623 Device::channel_groups()
625 map<string, shared_ptr<ChannelGroup>> result;
626 for (auto entry: _channel_groups)
628 auto name = entry.first;
629 auto channel_group = entry.second;
630 result[name] = channel_group->get_shared_pointer(get_shared_from_this());
637 check(sr_dev_open(_structure));
642 check(sr_dev_close(_structure));
645 HardwareDevice::HardwareDevice(shared_ptr<Driver> driver,
646 struct sr_dev_inst *structure) :
647 UserOwned(structure),
649 _driver(move(driver))
653 HardwareDevice::~HardwareDevice()
657 shared_ptr<Device> HardwareDevice::get_shared_from_this()
659 return static_pointer_cast<Device>(shared_from_this());
662 shared_ptr<Driver> HardwareDevice::driver()
667 UserDevice::UserDevice(string vendor, string model, string version) :
668 UserOwned(sr_dev_inst_user_new(
669 vendor.c_str(), model.c_str(), version.c_str())),
670 Device(UserOwned::_structure)
674 UserDevice::~UserDevice()
678 shared_ptr<Device> UserDevice::get_shared_from_this()
680 return static_pointer_cast<Device>(shared_from_this());
683 shared_ptr<Channel> UserDevice::add_channel(unsigned int index,
684 const ChannelType *type, string name)
686 check(sr_dev_inst_channel_add(Device::_structure,
687 index, type->id(), name.c_str()));
688 struct sr_channel *structure = (struct sr_channel *)
689 g_slist_last(sr_dev_inst_channels_get(Device::_structure))->data;
690 Channel *channel = new Channel(structure);
691 _channels[structure] = channel;
692 return get_channel(structure);
695 Channel::Channel(struct sr_channel *structure) :
696 ParentOwned(structure),
697 _type(ChannelType::get(_structure->type))
705 string Channel::name()
707 return valid_string(_structure->name);
710 void Channel::set_name(string name)
712 check(sr_dev_channel_name_set(_structure, name.c_str()));
715 const ChannelType *Channel::type()
717 return ChannelType::get(_structure->type);
720 bool Channel::enabled()
722 return _structure->enabled;
725 void Channel::set_enabled(bool value)
727 check(sr_dev_channel_enable(_structure, value));
730 unsigned int Channel::index()
732 return _structure->index;
735 ChannelGroup::ChannelGroup(Device *device,
736 struct sr_channel_group *structure) :
737 ParentOwned(structure),
738 Configurable(sr_dev_inst_driver_get(device->_structure), device->_structure, structure)
740 for (GSList *entry = structure->channels; entry; entry = entry->next)
741 _channels.push_back(device->_channels[(struct sr_channel *)entry->data]);
744 ChannelGroup::~ChannelGroup()
748 string ChannelGroup::name()
750 return valid_string(_structure->name);
753 vector<shared_ptr<Channel>> ChannelGroup::channels()
755 vector<shared_ptr<Channel>> result;
756 for (auto channel : _channels)
757 result.push_back(channel->get_shared_pointer(_parent));
761 Trigger::Trigger(shared_ptr<Context> context, string name) :
762 UserOwned(sr_trigger_new(name.c_str())),
763 _context(move(context))
765 for (auto stage = _structure->stages; stage; stage = stage->next)
767 new TriggerStage((struct sr_trigger_stage *) stage->data));
772 for (auto stage: _stages)
775 sr_trigger_free(_structure);
778 string Trigger::name()
780 return _structure->name;
783 vector<shared_ptr<TriggerStage>> Trigger::stages()
785 vector<shared_ptr<TriggerStage>> result;
786 for (auto stage : _stages)
787 result.push_back(stage->get_shared_pointer(this));
791 shared_ptr<TriggerStage> Trigger::add_stage()
793 auto stage = new TriggerStage(sr_trigger_stage_add(_structure));
794 _stages.push_back(stage);
795 return stage->get_shared_pointer(this);
798 TriggerStage::TriggerStage(struct sr_trigger_stage *structure) :
799 ParentOwned(structure)
803 TriggerStage::~TriggerStage()
805 for (auto match : _matches)
809 int TriggerStage::number()
811 return _structure->stage;
814 vector<shared_ptr<TriggerMatch>> TriggerStage::matches()
816 vector<shared_ptr<TriggerMatch>> result;
817 for (auto match : _matches)
818 result.push_back(match->get_shared_pointer(this));
822 void TriggerStage::add_match(shared_ptr<Channel> channel,
823 const TriggerMatchType *type, float value)
825 check(sr_trigger_match_add(_structure,
826 channel->_structure, type->id(), value));
827 _matches.push_back(new TriggerMatch(
828 (struct sr_trigger_match *) g_slist_last(
829 _structure->matches)->data, move(channel)));
832 void TriggerStage::add_match(shared_ptr<Channel> channel,
833 const TriggerMatchType *type)
835 add_match(move(channel), type, NAN);
838 TriggerMatch::TriggerMatch(struct sr_trigger_match *structure,
839 shared_ptr<Channel> channel) :
840 ParentOwned(structure),
841 _channel(move(channel))
845 TriggerMatch::~TriggerMatch()
849 shared_ptr<Channel> TriggerMatch::channel()
854 const TriggerMatchType *TriggerMatch::type()
856 return TriggerMatchType::get(_structure->match);
859 float TriggerMatch::value()
861 return _structure->value;
864 DatafeedCallbackData::DatafeedCallbackData(Session *session,
865 DatafeedCallbackFunction callback) :
866 _callback(move(callback)),
871 void DatafeedCallbackData::run(const struct sr_dev_inst *sdi,
872 const struct sr_datafeed_packet *pkt)
874 auto device = _session->get_device(sdi);
875 auto packet = shared_ptr<Packet>(new Packet(device, pkt), Packet::Deleter());
876 _callback(move(device), move(packet));
879 SessionDevice::SessionDevice(struct sr_dev_inst *structure) :
880 ParentOwned(structure),
885 SessionDevice::~SessionDevice()
889 shared_ptr<Device> SessionDevice::get_shared_from_this()
891 return static_pointer_cast<Device>(shared_from_this());
894 Session::Session(shared_ptr<Context> context) :
895 UserOwned(_structure),
896 _context(move(context))
898 check(sr_session_new(_context->_structure, &_structure));
899 _context->_session = this;
902 Session::Session(shared_ptr<Context> context, string filename) :
903 UserOwned(_structure),
904 _context(move(context)),
905 _filename(move(filename))
907 check(sr_session_load(_context->_structure, _filename.c_str(), &_structure));
909 check(sr_session_dev_list(_structure, &dev_list));
910 for (GSList *dev = dev_list; dev; dev = dev->next)
912 auto sdi = (struct sr_dev_inst *) dev->data;
913 _owned_devices[sdi] = new SessionDevice(sdi);
915 _context->_session = this;
920 check(sr_session_destroy(_structure));
922 for (auto callback : _datafeed_callbacks)
925 for (auto entry : _owned_devices)
929 shared_ptr<Device> Session::get_device(const struct sr_dev_inst *sdi)
931 if (_owned_devices.count(sdi))
932 return static_pointer_cast<Device>(
933 _owned_devices[sdi]->get_shared_pointer(this));
934 else if (_other_devices.count(sdi))
935 return _other_devices[sdi];
937 throw Error(SR_ERR_BUG);
940 void Session::add_device(shared_ptr<Device> device)
942 const auto dev_struct = device->_structure;
943 check(sr_session_dev_add(_structure, dev_struct));
944 _other_devices[dev_struct] = move(device);
947 vector<shared_ptr<Device>> Session::devices()
950 check(sr_session_dev_list(_structure, &dev_list));
951 vector<shared_ptr<Device>> result;
952 for (GSList *dev = dev_list; dev; dev = dev->next)
954 auto sdi = (struct sr_dev_inst *) dev->data;
955 result.push_back(get_device(sdi));
960 void Session::remove_devices()
962 _other_devices.clear();
963 check(sr_session_dev_remove_all(_structure));
966 void Session::start()
968 check(sr_session_start(_structure));
973 check(sr_session_run(_structure));
978 check(sr_session_stop(_structure));
981 bool Session::is_running() const
983 const int ret = sr_session_is_running(_structure);
989 static void session_stopped_callback(void *data)
991 auto *const callback = static_cast<SessionStoppedCallback*>(data);
995 void Session::set_stopped_callback(SessionStoppedCallback callback)
997 _stopped_callback = move(callback);
998 if (_stopped_callback)
999 check(sr_session_stopped_callback_set(_structure,
1000 &session_stopped_callback, &_stopped_callback));
1002 check(sr_session_stopped_callback_set(_structure,
1006 static void datafeed_callback(const struct sr_dev_inst *sdi,
1007 const struct sr_datafeed_packet *pkt, void *cb_data)
1009 auto callback = static_cast<DatafeedCallbackData *>(cb_data);
1010 callback->run(sdi, pkt);
1013 void Session::add_datafeed_callback(DatafeedCallbackFunction callback)
1015 auto cb_data = new DatafeedCallbackData(this, move(callback));
1016 check(sr_session_datafeed_callback_add(_structure,
1017 datafeed_callback, cb_data));
1018 _datafeed_callbacks.push_back(cb_data);
1021 void Session::remove_datafeed_callbacks()
1023 check(sr_session_datafeed_callback_remove_all(_structure));
1024 for (auto callback : _datafeed_callbacks)
1026 _datafeed_callbacks.clear();
1029 shared_ptr<Trigger> Session::trigger()
1034 void Session::set_trigger(shared_ptr<Trigger> trigger)
1037 // Set NULL trigger, i.e. remove any trigger from the session.
1038 check(sr_session_trigger_set(_structure, NULL));
1040 check(sr_session_trigger_set(_structure, trigger->_structure));
1041 _trigger = move(trigger);
1044 string Session::filename()
1049 shared_ptr<Context> Session::context()
1054 Packet::Packet(shared_ptr<Device> device,
1055 const struct sr_datafeed_packet *structure) :
1056 UserOwned(structure),
1057 _device(move(device))
1059 switch (structure->type)
1062 _payload = new Header(
1063 static_cast<const struct sr_datafeed_header *>(
1064 structure->payload));
1067 _payload = new Meta(
1068 static_cast<const struct sr_datafeed_meta *>(
1069 structure->payload));
1072 _payload = new Logic(
1073 static_cast<const struct sr_datafeed_logic *>(
1074 structure->payload));
1077 _payload = new Analog(
1078 static_cast<const struct sr_datafeed_analog *>(
1079 structure->payload));
1093 const PacketType *Packet::type()
1095 return PacketType::get(_structure->type);
1098 shared_ptr<PacketPayload> Packet::payload()
1101 return _payload->get_shared_pointer(this);
1103 throw Error(SR_ERR_NA);
1106 PacketPayload::PacketPayload()
1110 PacketPayload::~PacketPayload()
1114 Header::Header(const struct sr_datafeed_header *structure) :
1115 ParentOwned(structure),
1124 shared_ptr<PacketPayload> Header::get_shared_pointer(Packet *_parent)
1126 return static_pointer_cast<PacketPayload>(
1127 ParentOwned::get_shared_pointer(_parent));
1130 int Header::feed_version()
1132 return _structure->feed_version;
1135 Glib::TimeVal Header::start_time()
1137 return Glib::TimeVal(
1138 _structure->starttime.tv_sec,
1139 _structure->starttime.tv_usec);
1142 Meta::Meta(const struct sr_datafeed_meta *structure) :
1143 ParentOwned(structure),
1152 shared_ptr<PacketPayload> Meta::get_shared_pointer(Packet *_parent)
1154 return static_pointer_cast<PacketPayload>(
1155 ParentOwned::get_shared_pointer(_parent));
1158 map<const ConfigKey *, Glib::VariantBase> Meta::config()
1160 map<const ConfigKey *, Glib::VariantBase> result;
1161 for (auto l = _structure->config; l; l = l->next)
1163 auto config = (struct sr_config *) l->data;
1164 result[ConfigKey::get(config->key)] = Glib::VariantBase(config->data);
1169 Logic::Logic(const struct sr_datafeed_logic *structure) :
1170 ParentOwned(structure),
1179 shared_ptr<PacketPayload> Logic::get_shared_pointer(Packet *_parent)
1181 return static_pointer_cast<PacketPayload>(
1182 ParentOwned::get_shared_pointer(_parent));
1185 void *Logic::data_pointer()
1187 return _structure->data;
1190 size_t Logic::data_length()
1192 return _structure->length;
1195 unsigned int Logic::unit_size()
1197 return _structure->unitsize;
1200 Analog::Analog(const struct sr_datafeed_analog *structure) :
1201 ParentOwned(structure),
1210 shared_ptr<PacketPayload> Analog::get_shared_pointer(Packet *_parent)
1212 return static_pointer_cast<PacketPayload>(
1213 ParentOwned::get_shared_pointer(_parent));
1216 void *Analog::data_pointer()
1218 return _structure->data;
1221 unsigned int Analog::num_samples()
1223 return _structure->num_samples;
1226 vector<shared_ptr<Channel>> Analog::channels()
1228 vector<shared_ptr<Channel>> result;
1229 for (auto l = _structure->meaning->channels; l; l = l->next)
1230 result.push_back(_parent->_device->get_channel(
1231 (struct sr_channel *)l->data));
1235 const Quantity *Analog::mq()
1237 return Quantity::get(_structure->meaning->mq);
1240 const Unit *Analog::unit()
1242 return Unit::get(_structure->meaning->unit);
1245 vector<const QuantityFlag *> Analog::mq_flags()
1247 return QuantityFlag::flags_from_mask(_structure->meaning->mqflags);
1250 InputFormat::InputFormat(const struct sr_input_module *structure) :
1251 ParentOwned(structure)
1255 InputFormat::~InputFormat()
1259 string InputFormat::name()
1261 return valid_string(sr_input_id_get(_structure));
1264 string InputFormat::description()
1266 return valid_string(sr_input_description_get(_structure));
1269 vector<string> InputFormat::extensions()
1271 vector<string> exts;
1272 for (const char *const *e = sr_input_extensions_get(_structure);
1278 map<string, shared_ptr<Option>> InputFormat::options()
1280 const struct sr_option **options = sr_input_options_get(_structure);
1281 map<string, shared_ptr<Option>> result;
1284 auto option_array = shared_ptr<const struct sr_option *>(
1285 options, sr_input_options_free);
1286 for (int i = 0; options[i]; i++)
1287 result[options[i]->id] = shared_ptr<Option>(
1288 new Option(options[i], option_array), Option::Deleter());
1293 shared_ptr<Input> InputFormat::create_input(
1294 const map<string, Glib::VariantBase> &options)
1296 auto input = sr_input_new(_structure, map_to_hash_variant(options));
1298 throw Error(SR_ERR_ARG);
1299 return shared_ptr<Input>(
1300 new Input(_parent->shared_from_this(), input), Input::Deleter());
1303 Input::Input(shared_ptr<Context> context, const struct sr_input *structure) :
1304 UserOwned(structure),
1305 _context(move(context)),
1310 shared_ptr<InputDevice> Input::device()
1314 auto sdi = sr_input_dev_inst_get(_structure);
1316 throw Error(SR_ERR_NA);
1317 _device = new InputDevice(shared_from_this(), sdi);
1320 return _device->get_shared_pointer(shared_from_this());
1323 void Input::send(void *data, size_t length)
1325 auto gstr = g_string_new_len((gchar *)data, length);
1326 auto ret = sr_input_send(_structure, gstr);
1327 g_string_free(gstr, false);
1333 check(sr_input_end(_structure));
1340 sr_input_free(_structure);
1343 InputDevice::InputDevice(shared_ptr<Input> input,
1344 struct sr_dev_inst *structure) :
1345 ParentOwned(structure),
1351 InputDevice::~InputDevice()
1355 shared_ptr<Device> InputDevice::get_shared_from_this()
1357 return static_pointer_cast<Device>(shared_from_this());
1360 Option::Option(const struct sr_option *structure,
1361 shared_ptr<const struct sr_option *> structure_array) :
1362 UserOwned(structure),
1363 _structure_array(move(structure_array))
1373 return valid_string(_structure->id);
1376 string Option::name()
1378 return valid_string(_structure->name);
1381 string Option::description()
1383 return valid_string(_structure->desc);
1386 Glib::VariantBase Option::default_value()
1388 return Glib::VariantBase(_structure->def, true);
1391 vector<Glib::VariantBase> Option::values()
1393 vector<Glib::VariantBase> result;
1394 for (auto l = _structure->values; l; l = l->next)
1395 result.push_back(Glib::VariantBase((GVariant *) l->data, true));
1399 OutputFormat::OutputFormat(const struct sr_output_module *structure) :
1400 ParentOwned(structure)
1404 OutputFormat::~OutputFormat()
1408 string OutputFormat::name()
1410 return valid_string(sr_output_id_get(_structure));
1413 string OutputFormat::description()
1415 return valid_string(sr_output_description_get(_structure));
1418 vector<string> OutputFormat::extensions()
1420 vector<string> exts;
1421 for (const char *const *e = sr_output_extensions_get(_structure);
1427 map<string, shared_ptr<Option>> OutputFormat::options()
1429 const struct sr_option **options = sr_output_options_get(_structure);
1430 map<string, shared_ptr<Option>> result;
1433 auto option_array = shared_ptr<const struct sr_option *>(
1434 options, sr_output_options_free);
1435 for (int i = 0; options[i]; i++)
1436 result[options[i]->id] = shared_ptr<Option>(
1437 new Option(options[i], option_array), Option::Deleter());
1442 shared_ptr<Output> OutputFormat::create_output(
1443 shared_ptr<Device> device, const map<string, Glib::VariantBase> &options)
1445 return shared_ptr<Output>(
1446 new Output(shared_from_this(), move(device), options),
1450 shared_ptr<Output> OutputFormat::create_output(string filename,
1451 shared_ptr<Device> device, const map<string, Glib::VariantBase> &options)
1453 return shared_ptr<Output>(
1454 new Output(move(filename), shared_from_this(), move(device), options),
1458 bool OutputFormat::test_flag(const OutputFlag *flag)
1460 return sr_output_test_flag(_structure, flag->id());
1463 Output::Output(shared_ptr<OutputFormat> format,
1464 shared_ptr<Device> device, const map<string, Glib::VariantBase> &options) :
1465 UserOwned(sr_output_new(format->_structure,
1466 map_to_hash_variant(options), device->_structure, NULL)),
1467 _format(move(format)),
1468 _device(move(device)),
1473 Output::Output(string filename, shared_ptr<OutputFormat> format,
1474 shared_ptr<Device> device, const map<string, Glib::VariantBase> &options) :
1475 UserOwned(sr_output_new(format->_structure,
1476 map_to_hash_variant(options), device->_structure, filename.c_str())),
1477 _format(move(format)),
1478 _device(move(device)),
1485 check(sr_output_free(_structure));
1488 string Output::receive(shared_ptr<Packet> packet)
1491 check(sr_output_send(_structure, packet->_structure, &out));
1494 auto result = string(out->str, out->str + out->len);
1495 g_string_free(out, true);
1504 #include <enums.cpp>