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(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 = 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 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 vector<shared_ptr<Channel> > channels,
324 float *data_pointer, unsigned int num_samples, const Quantity *mq,
325 const Unit *unit, 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(), filename), Session::Deleter());
351 shared_ptr<Trigger> Context::create_trigger(string name)
353 return shared_ptr<Trigger>(
354 new Trigger(shared_from_this(), 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 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, Glib::VariantBase value)
484 config_sdi, config_channel_group,
485 key->id(), 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),
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())),
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, channel));
832 void TriggerStage::add_match(shared_ptr<Channel> channel,
833 const TriggerMatchType *type)
835 add_match(channel, type, NAN);
838 TriggerMatch::TriggerMatch(struct sr_trigger_match *structure,
839 shared_ptr<Channel> channel) :
840 ParentOwned(structure),
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) :
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(device, 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),
898 check(sr_session_new(context->_structure, &_structure));
899 _context->_session = this;
902 Session::Session(shared_ptr<Context> context, string filename) :
903 UserOwned(_structure),
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 check(sr_session_dev_add(_structure, device->_structure));
943 _other_devices[device->_structure] = device;
946 vector<shared_ptr<Device>> Session::devices()
949 check(sr_session_dev_list(_structure, &dev_list));
950 vector<shared_ptr<Device>> result;
951 for (GSList *dev = dev_list; dev; dev = dev->next)
953 auto sdi = (struct sr_dev_inst *) dev->data;
954 result.push_back(get_device(sdi));
959 void Session::remove_devices()
961 _other_devices.clear();
962 check(sr_session_dev_remove_all(_structure));
965 void Session::start()
967 check(sr_session_start(_structure));
972 check(sr_session_run(_structure));
977 check(sr_session_stop(_structure));
980 bool Session::is_running() const
982 const int ret = sr_session_is_running(_structure);
988 static void session_stopped_callback(void *data)
990 auto *const callback = static_cast<SessionStoppedCallback*>(data);
994 void Session::set_stopped_callback(SessionStoppedCallback callback)
996 _stopped_callback = move(callback);
997 if (_stopped_callback)
998 check(sr_session_stopped_callback_set(_structure,
999 &session_stopped_callback, &_stopped_callback));
1001 check(sr_session_stopped_callback_set(_structure,
1005 static void datafeed_callback(const struct sr_dev_inst *sdi,
1006 const struct sr_datafeed_packet *pkt, void *cb_data)
1008 auto callback = static_cast<DatafeedCallbackData *>(cb_data);
1009 callback->run(sdi, pkt);
1012 void Session::add_datafeed_callback(DatafeedCallbackFunction callback)
1014 auto cb_data = new DatafeedCallbackData(this, callback);
1015 check(sr_session_datafeed_callback_add(_structure,
1016 datafeed_callback, cb_data));
1017 _datafeed_callbacks.push_back(cb_data);
1020 void Session::remove_datafeed_callbacks(void)
1022 check(sr_session_datafeed_callback_remove_all(_structure));
1023 for (auto callback : _datafeed_callbacks)
1025 _datafeed_callbacks.clear();
1028 shared_ptr<Trigger> Session::trigger()
1033 void Session::set_trigger(shared_ptr<Trigger> trigger)
1036 // Set NULL trigger, i.e. remove any trigger from the session.
1037 check(sr_session_trigger_set(_structure, NULL));
1039 check(sr_session_trigger_set(_structure, trigger->_structure));
1043 string Session::filename()
1048 shared_ptr<Context> Session::context()
1053 Packet::Packet(shared_ptr<Device> device,
1054 const struct sr_datafeed_packet *structure) :
1055 UserOwned(structure),
1058 switch (structure->type)
1061 _payload = new Header(
1062 static_cast<const struct sr_datafeed_header *>(
1063 structure->payload));
1066 _payload = new Meta(
1067 static_cast<const struct sr_datafeed_meta *>(
1068 structure->payload));
1071 _payload = new Logic(
1072 static_cast<const struct sr_datafeed_logic *>(
1073 structure->payload));
1076 _payload = new Analog(
1077 static_cast<const struct sr_datafeed_analog *>(
1078 structure->payload));
1092 const PacketType *Packet::type()
1094 return PacketType::get(_structure->type);
1097 shared_ptr<PacketPayload> Packet::payload()
1100 return _payload->get_shared_pointer(this);
1102 throw Error(SR_ERR_NA);
1105 PacketPayload::PacketPayload()
1109 PacketPayload::~PacketPayload()
1113 Header::Header(const struct sr_datafeed_header *structure) :
1114 ParentOwned(structure),
1123 shared_ptr<PacketPayload> Header::get_shared_pointer(Packet *_parent)
1125 return static_pointer_cast<PacketPayload>(
1126 ParentOwned::get_shared_pointer(_parent));
1129 int Header::feed_version()
1131 return _structure->feed_version;
1134 Glib::TimeVal Header::start_time()
1136 return Glib::TimeVal(
1137 _structure->starttime.tv_sec,
1138 _structure->starttime.tv_usec);
1141 Meta::Meta(const struct sr_datafeed_meta *structure) :
1142 ParentOwned(structure),
1151 shared_ptr<PacketPayload> Meta::get_shared_pointer(Packet *_parent)
1153 return static_pointer_cast<PacketPayload>(
1154 ParentOwned::get_shared_pointer(_parent));
1157 map<const ConfigKey *, Glib::VariantBase> Meta::config()
1159 map<const ConfigKey *, Glib::VariantBase> result;
1160 for (auto l = _structure->config; l; l = l->next)
1162 auto config = (struct sr_config *) l->data;
1163 result[ConfigKey::get(config->key)] = Glib::VariantBase(config->data);
1168 Logic::Logic(const struct sr_datafeed_logic *structure) :
1169 ParentOwned(structure),
1178 shared_ptr<PacketPayload> Logic::get_shared_pointer(Packet *_parent)
1180 return static_pointer_cast<PacketPayload>(
1181 ParentOwned::get_shared_pointer(_parent));
1184 void *Logic::data_pointer()
1186 return _structure->data;
1189 size_t Logic::data_length()
1191 return _structure->length;
1194 unsigned int Logic::unit_size()
1196 return _structure->unitsize;
1199 Analog::Analog(const struct sr_datafeed_analog *structure) :
1200 ParentOwned(structure),
1209 shared_ptr<PacketPayload> Analog::get_shared_pointer(Packet *_parent)
1211 return static_pointer_cast<PacketPayload>(
1212 ParentOwned::get_shared_pointer(_parent));
1215 void *Analog::data_pointer()
1217 return _structure->data;
1220 unsigned int Analog::num_samples()
1222 return _structure->num_samples;
1225 vector<shared_ptr<Channel>> Analog::channels()
1227 vector<shared_ptr<Channel>> result;
1228 for (auto l = _structure->meaning->channels; l; l = l->next)
1229 result.push_back(_parent->_device->get_channel(
1230 (struct sr_channel *)l->data));
1234 const Quantity *Analog::mq()
1236 return Quantity::get(_structure->meaning->mq);
1239 const Unit *Analog::unit()
1241 return Unit::get(_structure->meaning->unit);
1244 vector<const QuantityFlag *> Analog::mq_flags()
1246 return QuantityFlag::flags_from_mask(_structure->meaning->mqflags);
1249 InputFormat::InputFormat(const struct sr_input_module *structure) :
1250 ParentOwned(structure)
1254 InputFormat::~InputFormat()
1258 string InputFormat::name()
1260 return valid_string(sr_input_id_get(_structure));
1263 string InputFormat::description()
1265 return valid_string(sr_input_description_get(_structure));
1268 vector<string> InputFormat::extensions()
1270 vector<string> exts;
1271 for (const char *const *e = sr_input_extensions_get(_structure);
1277 map<string, shared_ptr<Option>> InputFormat::options()
1279 const struct sr_option **options = sr_input_options_get(_structure);
1280 map<string, shared_ptr<Option>> result;
1283 auto option_array = shared_ptr<const struct sr_option *>(
1284 options, sr_input_options_free);
1285 for (int i = 0; options[i]; i++)
1286 result[options[i]->id] = shared_ptr<Option>(
1287 new Option(options[i], option_array), Option::Deleter());
1292 shared_ptr<Input> InputFormat::create_input(
1293 map<string, Glib::VariantBase> options)
1295 auto input = sr_input_new(_structure, map_to_hash_variant(options));
1297 throw Error(SR_ERR_ARG);
1298 return shared_ptr<Input>(
1299 new Input(_parent->shared_from_this(), input), Input::Deleter());
1302 Input::Input(shared_ptr<Context> context, const struct sr_input *structure) :
1303 UserOwned(structure),
1309 shared_ptr<InputDevice> Input::device()
1313 auto sdi = sr_input_dev_inst_get(_structure);
1315 throw Error(SR_ERR_NA);
1316 _device = new InputDevice(shared_from_this(), sdi);
1319 return _device->get_shared_pointer(shared_from_this());
1322 void Input::send(void *data, size_t length)
1324 auto gstr = g_string_new_len((gchar *)data, length);
1325 auto ret = sr_input_send(_structure, gstr);
1326 g_string_free(gstr, false);
1332 check(sr_input_end(_structure));
1339 sr_input_free(_structure);
1342 InputDevice::InputDevice(shared_ptr<Input> input,
1343 struct sr_dev_inst *structure) :
1344 ParentOwned(structure),
1350 InputDevice::~InputDevice()
1354 shared_ptr<Device> InputDevice::get_shared_from_this()
1356 return static_pointer_cast<Device>(shared_from_this());
1359 Option::Option(const struct sr_option *structure,
1360 shared_ptr<const struct sr_option *> structure_array) :
1361 UserOwned(structure),
1362 _structure_array(structure_array)
1372 return valid_string(_structure->id);
1375 string Option::name()
1377 return valid_string(_structure->name);
1380 string Option::description()
1382 return valid_string(_structure->desc);
1385 Glib::VariantBase Option::default_value()
1387 return Glib::VariantBase(_structure->def, true);
1390 vector<Glib::VariantBase> Option::values()
1392 vector<Glib::VariantBase> result;
1393 for (auto l = _structure->values; l; l = l->next)
1394 result.push_back(Glib::VariantBase((GVariant *) l->data, true));
1398 OutputFormat::OutputFormat(const struct sr_output_module *structure) :
1399 ParentOwned(structure)
1403 OutputFormat::~OutputFormat()
1407 string OutputFormat::name()
1409 return valid_string(sr_output_id_get(_structure));
1412 string OutputFormat::description()
1414 return valid_string(sr_output_description_get(_structure));
1417 vector<string> OutputFormat::extensions()
1419 vector<string> exts;
1420 for (const char *const *e = sr_output_extensions_get(_structure);
1426 map<string, shared_ptr<Option>> OutputFormat::options()
1428 const struct sr_option **options = sr_output_options_get(_structure);
1429 map<string, shared_ptr<Option>> result;
1432 auto option_array = shared_ptr<const struct sr_option *>(
1433 options, sr_output_options_free);
1434 for (int i = 0; options[i]; i++)
1435 result[options[i]->id] = shared_ptr<Option>(
1436 new Option(options[i], option_array), Option::Deleter());
1441 shared_ptr<Output> OutputFormat::create_output(
1442 shared_ptr<Device> device, map<string, Glib::VariantBase> options)
1444 return shared_ptr<Output>(
1445 new Output(shared_from_this(), device, options),
1449 shared_ptr<Output> OutputFormat::create_output(string filename,
1450 shared_ptr<Device> device, map<string, Glib::VariantBase> options)
1452 return shared_ptr<Output>(
1453 new Output(filename, shared_from_this(), device, options),
1457 bool OutputFormat::test_flag(const OutputFlag *flag)
1459 return sr_output_test_flag(_structure, flag->id());
1462 Output::Output(shared_ptr<OutputFormat> format,
1463 shared_ptr<Device> device, map<string, Glib::VariantBase> options) :
1464 UserOwned(sr_output_new(format->_structure,
1465 map_to_hash_variant(options), device->_structure, NULL)),
1472 Output::Output(string filename, shared_ptr<OutputFormat> format,
1473 shared_ptr<Device> device, map<string, Glib::VariantBase> options) :
1474 UserOwned(sr_output_new(format->_structure,
1475 map_to_hash_variant(options), device->_structure, filename.c_str())),
1484 check(sr_output_free(_structure));
1487 string Output::receive(shared_ptr<Packet> packet)
1490 check(sr_output_send(_structure, packet->_structure, &out));
1493 auto result = string(out->str, out->str + out->len);
1494 g_string_free(out, true);
1503 #include <enums.cpp>