#include "libsigrok/libsigrok.hpp"
-namespace sigrok
-{
+#include <sstream>
-/** Custom shared_ptr deleter for children owned by their parent object. */
-template <class T> void reset_parent(T *child)
+namespace sigrok
{
- child->parent.reset();
-}
/** Helper function to translate C errors to C++ exceptions. */
static void check(int result)
return "";
}
-/** Helper function to convert between map<string, string> and GHashTable */
-
-static GHashTable *map_to_hash(map<string, string> input)
+/** Helper function to convert between map<string, VariantBase> and GHashTable */
+static GHashTable *map_to_hash_variant(map<string, Glib::VariantBase> input)
{
auto output = g_hash_table_new_full(
- g_str_hash, g_str_equal, g_free, g_free);
+ g_variant_hash, g_variant_equal, g_free,
+ (void (*)(void *))g_variant_unref);
for (auto entry : input)
g_hash_table_insert(output,
g_strdup(entry.first.c_str()),
- g_strdup(entry.second.c_str()));
+ entry.second.gobj_copy());
return output;
}
for (int i = 0; driver_list[i]; i++)
drivers[driver_list[i]->name] =
new Driver(driver_list[i]);
- struct sr_input_format **input_list = sr_input_list();
+ const struct sr_input_module **input_list = sr_input_list();
if (input_list)
for (int i = 0; input_list[i]; i++)
- input_formats[input_list[i]->id] =
+ input_formats[sr_input_id_get(input_list[i])] =
new InputFormat(input_list[i]);
- struct sr_output_format **output_list = sr_output_list();
+ const struct sr_output_module **output_list = sr_output_list();
if (output_list)
for (int i = 0; output_list[i]; i++)
- output_formats[output_list[i]->id] =
+ output_formats[sr_output_id_get(output_list[i])] =
new OutputFormat(output_list[i]);
}
{
auto name = entry.first;
auto driver = entry.second;
- driver->parent = static_pointer_cast<Context>(shared_from_this());
- result[name] = shared_ptr<Driver>(driver, reset_parent<Driver>);
+ result[name] = static_pointer_cast<Driver>(
+ driver->get_shared_pointer(this));
}
return result;
}
{
auto name = entry.first;
auto input_format = entry.second;
- input_format->parent = static_pointer_cast<Context>(shared_from_this());
- result[name] = shared_ptr<InputFormat>(input_format,
- reset_parent<InputFormat>);
+ result[name] = static_pointer_cast<InputFormat>(
+ input_format->get_shared_pointer(this));
}
return result;
}
{
auto name = entry.first;
auto output_format = entry.second;
- output_format->parent = static_pointer_cast<Context>(shared_from_this());
- result[name] = shared_ptr<OutputFormat>(output_format,
- reset_parent<OutputFormat>);
+ result[name] = static_pointer_cast<OutputFormat>(
+ output_format->get_shared_pointer(this));
}
return result;
}
new Trigger(shared_from_this(), name), Trigger::Deleter());
}
+shared_ptr<Input> Context::open_file(string filename)
+{
+ auto input = sr_input_scan_file(filename.c_str());
+ if (!input)
+ throw Error(SR_ERR_NA);
+ return shared_ptr<Input>(
+ new Input(shared_from_this(), input), Input::Deleter());
+}
+
+shared_ptr<Input> Context::open_stream(string header)
+{
+ auto gstr = g_string_new(header.c_str());
+ auto input = sr_input_scan_buffer(gstr);
+ g_string_free(gstr, false);
+ if (!input)
+ throw Error(SR_ERR_NA);
+ return shared_ptr<Input>(
+ new Input(shared_from_this(), input), Input::Deleter());
+}
+
Driver::Driver(struct sr_dev_driver *structure) :
StructureWrapper<Context, struct sr_dev_driver>(structure),
initialized(false)
/* Create list of shared pointers to device instances for return. */
vector<shared_ptr<HardwareDevice>> result;
for (auto device : devices)
- {
- device->parent = parent->shared_from_this();
- result.push_back(shared_ptr<HardwareDevice>(device,
- reset_parent<HardwareDevice>));
- }
+ result.push_back(static_pointer_cast<HardwareDevice>(
+ device->get_shared_pointer(parent)));
return result;
}
key->get_id(), value.gobj()));
}
-Glib::VariantBase Configurable::config_list(const ConfigKey *key)
+Glib::VariantContainerBase Configurable::config_list(const ConfigKey *key)
{
GVariant *data;
check(sr_config_list(
config_driver, config_sdi, config_channel_group,
key->get_id(), &data));
- return Glib::VariantBase(data);
+ return Glib::VariantContainerBase(data);
}
Device::Device(struct sr_dev_inst *structure) :
for (GSList *entry = structure->channels; entry; entry = entry->next)
{
auto channel = (struct sr_channel *) entry->data;
- channels.push_back(new Channel(channel));
+ channels[channel] = new Channel(channel);
+ }
+
+ for (GSList *entry = structure->channel_groups; entry; entry = entry->next)
+ {
+ auto group = (struct sr_channel_group *) entry->data;
+ channel_groups[group->name] = new ChannelGroup(this, group);
}
}
Device::~Device()
{
- for (auto channel : channels)
- delete channel;
+ for (auto entry : channels)
+ delete entry.second;
+ for (auto entry : channel_groups)
+ delete entry.second;
+}
+
+string Device::get_description()
+{
+ ostringstream s;
+
+ vector<string> parts =
+ {get_vendor(), get_model(), get_version()};
+
+ for (string part : parts)
+ if (part.length() > 0)
+ s << part;
+
+ return s.str();
}
string Device::get_vendor()
vector<shared_ptr<Channel>> Device::get_channels()
{
vector<shared_ptr<Channel>> result;
- for (auto channel : channels)
+ for (auto entry : channels)
+ result.push_back(static_pointer_cast<Channel>(
+ entry.second->get_shared_pointer(this)));
+ return result;
+}
+
+shared_ptr<Channel> Device::get_channel(struct sr_channel *ptr)
+{
+ return static_pointer_cast<Channel>(
+ channels[ptr]->get_shared_pointer(this));
+}
+
+map<string, shared_ptr<ChannelGroup>>
+Device::get_channel_groups()
+{
+ map<string, shared_ptr<ChannelGroup>> result;
+ for (auto entry: channel_groups)
{
- channel->parent = static_pointer_cast<Device>(shared_from_this());
- result.push_back(shared_ptr<Channel>(channel, reset_parent<Channel>));
+ auto name = entry.first;
+ auto channel_group = entry.second;
+ result[name] = static_pointer_cast<ChannelGroup>(
+ channel_group->get_shared_pointer(this));
}
return result;
}
Device(structure),
driver(driver)
{
- for (GSList *entry = structure->channel_groups; entry; entry = entry->next)
- {
- auto group = (struct sr_channel_group *) entry->data;
- channel_groups[group->name] = new ChannelGroup(this, group);
- }
}
HardwareDevice::~HardwareDevice()
{
- for (auto entry : channel_groups)
- delete entry.second;
}
shared_ptr<Driver> HardwareDevice::get_driver()
{
- return static_pointer_cast<Driver>(driver->shared_from_this());
-}
-
-map<string, shared_ptr<ChannelGroup>>
-HardwareDevice::get_channel_groups()
-{
- map<string, shared_ptr<ChannelGroup>> result;
- for (auto entry: channel_groups)
- {
- auto name = entry.first;
- auto channel_group = entry.second;
- channel_group->parent =
- static_pointer_cast<HardwareDevice>(shared_from_this());
- result[name] = shared_ptr<ChannelGroup>(channel_group,
- reset_parent<ChannelGroup>);
- }
- return result;
+ return static_pointer_cast<Driver>(driver->get_shared_pointer(parent));
}
Channel::Channel(struct sr_channel *structure) :
check(sr_dev_channel_enable(parent->structure, structure->index, value));
}
-ChannelGroup::ChannelGroup(HardwareDevice *device,
+unsigned int Channel::get_index()
+{
+ return structure->index;
+}
+
+ChannelGroup::ChannelGroup(Device *device,
struct sr_channel_group *structure) :
- StructureWrapper<HardwareDevice, struct sr_channel_group>(structure),
+ StructureWrapper<Device, struct sr_channel_group>(structure),
Configurable(device->structure->driver, device->structure, structure)
{
for (GSList *entry = structure->channels; entry; entry = entry->next)
- {
- auto channel = (struct sr_channel *) entry->data;
- for (auto device_channel : device->channels)
- if (channel == device_channel->structure)
- channels.push_back(device_channel);
- }
+ channels.push_back(device->channels[(struct sr_channel *)entry->data]);
}
ChannelGroup::~ChannelGroup()
{
vector<shared_ptr<Channel>> result;
for (auto channel : channels)
- {
- channel->parent = static_pointer_cast<Device>(parent->shared_from_this());
- result.push_back(shared_ptr<Channel>(channel, reset_parent<Channel>));
- }
+ result.push_back(static_pointer_cast<Channel>(
+ channel->get_shared_pointer(parent)));
return result;
}
{
vector<shared_ptr<TriggerStage>> result;
for (auto stage : stages)
- {
- stage->parent = static_pointer_cast<Trigger>(shared_from_this());
- result.push_back(shared_ptr<TriggerStage>(stage, reset_parent<TriggerStage>));
- }
+ result.push_back(static_pointer_cast<TriggerStage>(
+ stage->get_shared_pointer(this)));
return result;
}
{
auto stage = new TriggerStage(sr_trigger_stage_add(structure));
stages.push_back(stage);
- stage->parent = static_pointer_cast<Trigger>(shared_from_this());
- return shared_ptr<TriggerStage>(stage, reset_parent<TriggerStage>);
+ return static_pointer_cast<TriggerStage>(
+ stage->get_shared_pointer(this));
}
TriggerStage::TriggerStage(struct sr_trigger_stage *structure) :
{
vector<shared_ptr<TriggerMatch>> result;
for (auto match : matches)
- {
- match->parent = static_pointer_cast<TriggerStage>(shared_from_this());
- result.push_back(shared_ptr<TriggerMatch>(match, reset_parent<TriggerMatch>));
- }
+ result.push_back(static_pointer_cast<TriggerMatch>(
+ match->get_shared_pointer(this)));
return result;
}
const struct sr_datafeed_packet *pkt)
{
auto device = session->devices[sdi];
- auto packet = shared_ptr<Packet>(new Packet(pkt), Packet::Deleter());
+ auto packet = shared_ptr<Packet>(new Packet(device, pkt), Packet::Deleter());
callback(device, packet);
}
save_samplerate = 0;
}
-void Session::append(shared_ptr<Device> device, shared_ptr<Packet> packet)
+void Session::append(shared_ptr<Packet> packet)
{
if (!saving)
throw Error(SR_ERR);
{
GVariant *samplerate;
- check(sr_config_get(device->structure->driver,
- device->structure, NULL, SR_CONF_SAMPLERATE, &samplerate));
+ check(sr_config_get(packet->device->structure->driver,
+ packet->device->structure, NULL, SR_CONF_SAMPLERATE,
+ &samplerate));
save_samplerate = g_variant_get_uint64(samplerate);
{
vector<shared_ptr<Channel>> save_channels;
- for (auto channel : device->get_channels())
+ for (auto channel : packet->device->get_channels())
if (channel->structure->enabled &&
channel->structure->type == SR_CHANNEL_LOGIC)
save_channels.push_back(channel);
}
}
+void Session::append(void *data, size_t length, unsigned int unit_size)
+{
+ check(sr_session_append(structure, save_filename.c_str(),
+ (uint8_t *) data, unit_size, length));
+}
+
static void datafeed_callback(const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *pkt, void *cb_data)
{
this->trigger = trigger;
}
-Packet::Packet(const struct sr_datafeed_packet *structure) :
- structure(structure)
+Packet::Packet(shared_ptr<Device> device,
+ const struct sr_datafeed_packet *structure) :
+ structure(structure),
+ device(device)
{
switch (structure->type)
{
+ case SR_DF_HEADER:
+ payload = new Header(
+ static_cast<const struct sr_datafeed_header *>(
+ structure->payload));
+ break;
+ case SR_DF_META:
+ payload = new Meta(
+ static_cast<const struct sr_datafeed_meta *>(
+ structure->payload));
+ break;
case SR_DF_LOGIC:
payload = new Logic(
static_cast<const struct sr_datafeed_logic *>(
static_cast<const struct sr_datafeed_analog *>(
structure->payload));
break;
- default:
- payload = NULL;
- break;
}
}
Packet::~Packet()
{
- delete payload;
+ if (payload)
+ delete payload;
}
const PacketType *Packet::get_type()
return PacketType::get(structure->type);
}
-PacketPayload *Packet::get_payload()
+shared_ptr<PacketPayload> Packet::get_payload()
{
- return payload;
+ return payload->get_shared_pointer(this);
}
PacketPayload::PacketPayload()
{
}
-Logic::Logic(const struct sr_datafeed_logic *structure) : PacketPayload(),
- structure(structure),
- data(static_cast<uint8_t *>(structure->data),
- static_cast<uint8_t *>(structure->data) + structure->length) {}
+Header::Header(const struct sr_datafeed_header *structure) :
+ PacketPayload(),
+ StructureWrapper<Packet, const struct sr_datafeed_header>(structure)
+{
+}
+
+Header::~Header()
+{
+}
+
+int Header::get_feed_version()
+{
+ return structure->feed_version;
+}
+
+Glib::TimeVal Header::get_start_time()
+{
+ return Glib::TimeVal(
+ structure->starttime.tv_sec,
+ structure->starttime.tv_usec);
+}
+
+Meta::Meta(const struct sr_datafeed_meta *structure) :
+ PacketPayload(),
+ StructureWrapper<Packet, const struct sr_datafeed_meta>(structure)
+{
+}
+
+Meta::~Meta()
+{
+}
+
+map<const ConfigKey *, Glib::VariantBase> Meta::get_config()
+{
+ map<const ConfigKey *, Glib::VariantBase> result;
+ for (auto l = structure->config; l; l = l->next)
+ {
+ auto config = (struct sr_config *) l->data;
+ result[ConfigKey::get(config->key)] = Glib::VariantBase(config->data);
+ }
+ return result;
+}
+
+Logic::Logic(const struct sr_datafeed_logic *structure) :
+ PacketPayload(),
+ StructureWrapper<Packet, const struct sr_datafeed_logic>(structure)
+{
+}
Logic::~Logic()
{
}
-void *Logic::get_data()
+void *Logic::get_data_pointer()
{
return structure->data;
}
-size_t Logic::get_data_size()
+size_t Logic::get_data_length()
{
return structure->length;
}
+unsigned int Logic::get_unit_size()
+{
+ return structure->unitsize;
+}
+
Analog::Analog(const struct sr_datafeed_analog *structure) :
PacketPayload(),
- structure(structure)
+ StructureWrapper<Packet, const struct sr_datafeed_analog>(structure)
{
}
{
}
-void *Analog::get_data()
+float *Analog::get_data_pointer()
{
return structure->data;
}
-size_t Analog::get_data_size()
+unsigned int Analog::get_num_samples()
{
- return structure->num_samples * sizeof(float);
+ return structure->num_samples;
}
-unsigned int Analog::get_num_samples()
+vector<shared_ptr<Channel>> Analog::get_channels()
{
- return structure->num_samples;
+ vector<shared_ptr<Channel>> result;
+ for (auto l = structure->channels; l; l = l->next)
+ result.push_back(parent->device->get_channel(
+ (struct sr_channel *)l->data));
+ return result;
}
const Quantity *Analog::get_mq()
return QuantityFlag::flags_from_mask(structure->mqflags);
}
-InputFormat::InputFormat(struct sr_input_format *structure) :
- StructureWrapper<Context, struct sr_input_format>(structure)
+InputFormat::InputFormat(const struct sr_input_module *structure) :
+ StructureWrapper<Context, const struct sr_input_module>(structure)
{
}
string InputFormat::get_name()
{
- return valid_string(structure->id);
+ return valid_string(sr_input_id_get(structure));
}
string InputFormat::get_description()
{
- return valid_string(structure->description);
+ return valid_string(sr_input_description_get(structure));
}
-bool InputFormat::format_match(string filename)
+shared_ptr<Input> InputFormat::create_input(
+ map<string, Glib::VariantBase> options)
+{
+ auto input = sr_input_new(structure, map_to_hash_variant(options));
+ if (!input)
+ throw Error(SR_ERR_ARG);
+ return shared_ptr<Input>(
+ new Input(parent->shared_from_this(), input), Input::Deleter());
+}
+
+Input::Input(shared_ptr<Context> context, const struct sr_input *structure) :
+ structure(structure),
+ context(context),
+ device(nullptr)
+{
+}
+
+shared_ptr<InputDevice> Input::get_device()
+{
+ if (!device)
+ {
+ auto sdi = sr_input_dev_inst_get(structure);
+ if (!sdi)
+ throw Error(SR_ERR_NA);
+ device = new InputDevice(shared_from_this(), sdi);
+ }
+
+ return static_pointer_cast<InputDevice>(
+ device->get_shared_pointer(context->shared_from_this()));
+}
+
+void Input::send(string data)
+{
+ auto gstr = g_string_new(data.c_str());
+ auto ret = sr_input_send(structure, gstr);
+ g_string_free(gstr, false);
+ check(ret);
+}
+
+Input::~Input()
+{
+ if (device)
+ delete device;
+ check(sr_input_free(structure));
+}
+
+InputDevice::InputDevice(shared_ptr<Input> input, struct sr_dev_inst *sdi) :
+ Device(sdi),
+ input(input)
+{
+}
+
+InputDevice::~InputDevice()
+{
+}
+
+Option::Option(const struct sr_option *structure,
+ shared_ptr<const struct sr_option *> structure_array) :
+ structure(structure),
+ structure_array(structure_array)
{
- return structure->format_match(filename.c_str());
}
-shared_ptr<InputFileDevice> InputFormat::open_file(string filename,
- map<string, string> options)
+Option::~Option()
{
- auto input = g_new(struct sr_input, 1);
- input->param = map_to_hash(options);
+}
- /** Run initialisation. */
- check(structure->init(input, filename.c_str()));
+string Option::get_id()
+{
+ return valid_string(structure->id);
+}
- /** Create virtual device. */
- return shared_ptr<InputFileDevice>(new InputFileDevice(
- static_pointer_cast<InputFormat>(shared_from_this()), input, filename),
- InputFileDevice::Deleter());
+string Option::get_name()
+{
+ return valid_string(structure->name);
}
-InputFileDevice::InputFileDevice(shared_ptr<InputFormat> format,
- struct sr_input *input, string filename) :
- Device(input->sdi),
- input(input),
- format(format),
- filename(filename)
+string Option::get_description()
{
+ return valid_string(structure->desc);
}
-InputFileDevice::~InputFileDevice()
+Glib::VariantBase Option::get_default_value()
{
- g_hash_table_unref(input->param);
- g_free(input);
+ return Glib::VariantBase(structure->def, true);
}
-void InputFileDevice::load()
+vector<Glib::VariantBase> Option::get_values()
{
- check(format->structure->loadfile(input, filename.c_str()));
+ vector<Glib::VariantBase> result;
+ for (auto l = structure->values; l; l = l->next)
+ result.push_back(Glib::VariantBase((GVariant *) l->data, true));
+ return result;
}
-OutputFormat::OutputFormat(struct sr_output_format *structure) :
- StructureWrapper<Context, struct sr_output_format>(structure)
+OutputFormat::OutputFormat(const struct sr_output_module *structure) :
+ StructureWrapper<Context, const struct sr_output_module>(structure)
{
}
string OutputFormat::get_name()
{
- return valid_string(structure->id);
+ return valid_string(sr_output_id_get(structure));
}
string OutputFormat::get_description()
{
- return valid_string(structure->description);
+ return valid_string(sr_output_description_get(structure));
+}
+
+map<string, shared_ptr<Option>> OutputFormat::get_options()
+{
+ const struct sr_option **options = sr_output_options_get(structure);
+ auto option_array = shared_ptr<const struct sr_option *>(
+ options, sr_output_options_free);
+ map<string, shared_ptr<Option>> result;
+ for (int i = 0; options[i]; i++)
+ result[options[i]->id] = shared_ptr<Option>(
+ new Option(options[i], option_array), Option::Deleter());
+ return result;
}
shared_ptr<Output> OutputFormat::create_output(
- shared_ptr<Device> device, map<string, string> options)
+ shared_ptr<Device> device, map<string, Glib::VariantBase> options)
{
return shared_ptr<Output>(
new Output(
}
Output::Output(shared_ptr<OutputFormat> format,
- shared_ptr<Device> device, map<string, string> options) :
+ shared_ptr<Device> device, map<string, Glib::VariantBase> options) :
structure(sr_output_new(format->structure,
- map_to_hash(options), device->structure)),
+ map_to_hash_variant(options), device->structure)),
format(format), device(device), options(options)
{
}
Output::~Output()
{
- g_hash_table_unref(structure->params);
check(sr_output_free(structure));
}
projects / libsigrok.git / blobdiff