bindings/cxx/classes.cpp

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013-2014 Martin Ling <martin-sigrok@earth.li>
   5  *
   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.
  10  *
  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.
  15  *
  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/>.
  18  */
  19
  20 #include "libsigrok/libsigrok.hpp"
  21
  22 #include <sstream>
  23 #include <cmath>
  24
  25 namespace sigrok
  26 {
  27
  28 /** Helper function to translate C errors to C++ exceptions. */
  29 static void check(int result)
  30 {
  31         if (result != SR_OK)
  32                 throw Error(result);
  33 }
  34
  35 /** Helper function to obtain valid strings from possibly null input. */
  36 static const char *valid_string(const char *input)
  37 {
  38         if (input != NULL)
  39                 return input;
  40         else
  41                 return "";
  42 }
  43
  44 /** Helper function to convert between map<string, VariantBase> and GHashTable */
  45 static GHashTable *map_to_hash_variant(map<string, Glib::VariantBase> input)
  46 {
  47         auto output = g_hash_table_new_full(
  48                 g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
  49         for (auto entry : input)
  50                 g_hash_table_insert(output,
  51                         g_strdup(entry.first.c_str()),
  52                         entry.second.gobj_copy());
  53     return output;
  54 }
  55
  56 Error::Error(int result) : result(result)
  57 {
  58 }
  59
  60 const char *Error::what() const throw()
  61 {
  62         return sr_strerror(result);
  63 }
  64
  65 Error::~Error() throw()
  66 {
  67 }
  68
  69 shared_ptr<Context> Context::create()
  70 {
  71         return shared_ptr<Context>(new Context(), Context::Deleter());
  72 }
  73
  74 Context::Context() :
  75         UserOwned(_structure),
  76         _session(NULL)
  77 {
  78         check(sr_init(&_structure));
  79
  80         struct sr_dev_driver **driver_list = sr_driver_list();
  81         if (driver_list)
  82                 for (int i = 0; driver_list[i]; i++)
  83                         _drivers[driver_list[i]->name] =
  84                                 new Driver(driver_list[i]);
  85         const struct sr_input_module **input_list = sr_input_list();
  86         if (input_list)
  87                 for (int i = 0; input_list[i]; i++)
  88                         _input_formats[sr_input_id_get(input_list[i])] =
  89                                 new InputFormat(input_list[i]);
  90         const struct sr_output_module **output_list = sr_output_list();
  91         if (output_list)
  92                 for (int i = 0; output_list[i]; i++)
  93                         _output_formats[sr_output_id_get(output_list[i])] =
  94                                 new OutputFormat(output_list[i]);
  95 }
  96
  97 string Context::package_version()
  98 {
  99         return sr_package_version_string_get();
 100 }
 101
 102 string Context::lib_version()
 103 {
 104         return sr_lib_version_string_get();
 105 }
 106
 107 map<string, shared_ptr<Driver>> Context::drivers()
 108 {
 109         map<string, shared_ptr<Driver>> result;
 110         for (auto entry: _drivers)
 111         {
 112                 auto name = entry.first;
 113                 auto driver = entry.second;
 114                 result[name] = driver->get_shared_pointer(this);
 115         }
 116         return result;
 117 }
 118
 119 map<string, shared_ptr<InputFormat>> Context::input_formats()
 120 {
 121         map<string, shared_ptr<InputFormat>> result;
 122         for (auto entry: _input_formats)
 123         {
 124                 auto name = entry.first;
 125                 auto input_format = entry.second;
 126                 result[name] = input_format->get_shared_pointer(this);
 127         }
 128         return result;
 129 }
 130
 131 map<string, shared_ptr<OutputFormat>> Context::output_formats()
 132 {
 133         map<string, shared_ptr<OutputFormat>> result;
 134         for (auto entry: _output_formats)
 135         {
 136                 auto name = entry.first;
 137                 auto output_format = entry.second;
 138                 result[name] = output_format->get_shared_pointer(this);
 139         }
 140         return result;
 141 }
 142
 143 Context::~Context()
 144 {
 145         for (auto entry : _drivers)
 146                 delete entry.second;
 147         for (auto entry : _input_formats)
 148                 delete entry.second;
 149         for (auto entry : _output_formats)
 150                 delete entry.second;
 151         check(sr_exit(_structure));
 152 }
 153
 154 const LogLevel *Context::log_level()
 155 {
 156         return LogLevel::get(sr_log_loglevel_get());
 157 }
 158
 159 void Context::set_log_level(const LogLevel *level)
 160 {
 161         check(sr_log_loglevel_set(level->id()));
 162 }
 163
 164 string Context::log_domain()
 165 {
 166         return valid_string(sr_log_logdomain_get());
 167 }
 168
 169 void Context::set_log_domain(string value)
 170 {
 171         check(sr_log_logdomain_set(value.c_str()));
 172 }
 173
 174 static int call_log_callback(void *cb_data, int loglevel, const char *format, va_list args)
 175 {
 176         va_list args_copy;
 177         va_copy(args_copy, args);
 178         int length = vsnprintf(NULL, 0, format, args_copy);
 179         va_end(args_copy);
 180         char *buf = (char *) g_malloc(length + 1);
 181         vsprintf(buf, format, args);
 182         string message(buf, length);
 183         g_free(buf);
 184
 185         LogCallbackFunction callback = *((LogCallbackFunction *) cb_data);
 186
 187         try
 188         {
 189                 callback(LogLevel::get(loglevel), message);
 190         }
 191         catch (Error e)
 192         {
 193                 return e.result;
 194         }
 195
 196         return SR_OK;
 197 }
 198
 199 void Context::set_log_callback(LogCallbackFunction callback)
 200 {
 201         _log_callback = callback;
 202         check(sr_log_callback_set(call_log_callback, &_log_callback));
 203 }
 204
 205 void Context::set_log_callback_default()
 206 {
 207         check(sr_log_callback_set_default());
 208         _log_callback = nullptr;
 209 }
 210
 211 shared_ptr<Session> Context::create_session()
 212 {
 213         return shared_ptr<Session>(
 214                 new Session(shared_from_this()), Session::Deleter());
 215 }
 216
 217 shared_ptr<Session> Context::load_session(string filename)
 218 {
 219         return shared_ptr<Session>(
 220                 new Session(shared_from_this(), filename), Session::Deleter());
 221 }
 222
 223 shared_ptr<Trigger> Context::create_trigger(string name)
 224 {
 225         return shared_ptr<Trigger>(
 226                 new Trigger(shared_from_this(), name), Trigger::Deleter());
 227 }
 228
 229 shared_ptr<Input> Context::open_file(string filename)
 230 {
 231         const struct sr_input *input;
 232
 233         check(sr_input_scan_file(filename.c_str(), &input));
 234         return shared_ptr<Input>(
 235                 new Input(shared_from_this(), input), Input::Deleter());
 236 }
 237
 238 shared_ptr<Input> Context::open_stream(string header)
 239 {
 240         const struct sr_input *input;
 241
 242         auto gstr = g_string_new(header.c_str());
 243         auto ret = sr_input_scan_buffer(gstr, &input);
 244         g_string_free(gstr, true);
 245         check(ret);
 246         return shared_ptr<Input>(
 247                 new Input(shared_from_this(), input), Input::Deleter());
 248 }
 249
 250 Driver::Driver(struct sr_dev_driver *structure) :
 251         ParentOwned(structure),
 252         Configurable(structure, NULL, NULL),
 253         _initialized(false)
 254 {
 255 }
 256
 257 Driver::~Driver()
 258 {
 259         for (auto device : _devices)
 260                 delete device;
 261 }
 262
 263 string Driver::name()
 264 {
 265         return valid_string(_structure->name);
 266 }
 267
 268 string Driver::long_name()
 269 {
 270         return valid_string(_structure->longname);
 271 }
 272
 273 vector<shared_ptr<HardwareDevice>> Driver::scan(
 274         map<const ConfigKey *, Glib::VariantBase> options)
 275 {
 276         /* Initialise the driver if not yet done. */
 277         if (!_initialized)
 278         {
 279                 check(sr_driver_init(_parent->_structure, _structure));
 280                 _initialized = true;
 281         }
 282
 283         /* Clear all existing instances. */
 284         for (auto device : _devices)
 285                 delete device;
 286         _devices.clear();
 287
 288         /* Translate scan options to GSList of struct sr_config pointers. */
 289         GSList *option_list = NULL;
 290         for (auto entry : options)
 291         {
 292                 auto key = entry.first;
 293                 auto value = entry.second;
 294                 auto config = g_new(struct sr_config, 1);
 295                 config->key = key->id();
 296                 config->data = value.gobj();
 297                 option_list = g_slist_append(option_list, config);
 298         }
 299
 300         /* Run scan. */
 301         GSList *device_list = sr_driver_scan(_structure, option_list);
 302
 303         /* Free option list. */
 304         g_slist_free_full(option_list, g_free);
 305
 306         /* Create device objects. */
 307         for (GSList *device = device_list; device; device = device->next)
 308         {
 309                 auto sdi = (struct sr_dev_inst *) device->data;
 310                 _devices.push_back(new HardwareDevice(this, sdi));
 311         }
 312
 313         /* Free GSList returned from scan. */
 314         g_slist_free(device_list);
 315
 316         /* Create list of shared pointers to device instances for return. */
 317         vector<shared_ptr<HardwareDevice>> result;
 318         for (auto device : _devices)
 319                 result.push_back(device->get_shared_pointer(_parent));
 320         return result;
 321 }
 322
 323 Configurable::Configurable(
 324                 struct sr_dev_driver *driver,
 325                 struct sr_dev_inst *sdi,
 326                 struct sr_channel_group *cg) :
 327         config_driver(driver),
 328         config_sdi(sdi),
 329         config_channel_group(cg)
 330 {
 331 }
 332
 333 Configurable::~Configurable()
 334 {
 335 }
 336
 337 Glib::VariantBase Configurable::config_get(const ConfigKey *key)
 338 {
 339         GVariant *data;
 340         check(sr_config_get(
 341                 config_driver, config_sdi, config_channel_group,
 342                 key->id(), &data));
 343         return Glib::VariantBase(data);
 344 }
 345
 346 void Configurable::config_set(const ConfigKey *key, Glib::VariantBase value)
 347 {
 348         check(sr_config_set(
 349                 config_sdi, config_channel_group,
 350                 key->id(), value.gobj()));
 351 }
 352
 353 Glib::VariantContainerBase Configurable::config_list(const ConfigKey *key)
 354 {
 355         GVariant *data;
 356         check(sr_config_list(
 357                 config_driver, config_sdi, config_channel_group,
 358                 key->id(), &data));
 359         return Glib::VariantContainerBase(data);
 360 }
 361
 362 vector<const ConfigKey *> Configurable::config_keys(const ConfigKey *key)
 363 {
 364         GVariant *gvar_opts;
 365         gsize num_opts;
 366         const int32_t *opts;
 367         vector<const ConfigKey *> result;
 368
 369         check(sr_config_list(
 370                 config_driver, config_sdi, config_channel_group,
 371                 key->id(), &gvar_opts));
 372
 373         opts = (const int32_t *) g_variant_get_fixed_array(
 374                 gvar_opts, &num_opts, sizeof(int32_t));
 375
 376         for (gsize i = 0; i < num_opts; i++)
 377                 result.push_back(ConfigKey::get(opts[i]));
 378
 379         g_variant_unref(gvar_opts);
 380
 381         return result;
 382 }
 383
 384 bool Configurable::config_check(const ConfigKey *key,
 385         const ConfigKey *index_key)
 386 {
 387         GVariant *gvar_opts;
 388         gsize num_opts;
 389         const int32_t *opts;
 390
 391         if (sr_config_list(config_driver, config_sdi, config_channel_group,
 392                         index_key->id(), &gvar_opts) != SR_OK)
 393                 return false;
 394
 395         opts = (const int32_t *) g_variant_get_fixed_array(
 396                 gvar_opts, &num_opts, sizeof(int32_t));
 397
 398         for (gsize i = 0; i < num_opts; i++)
 399         {
 400                 if (opts[i] == key->id())
 401                 {
 402                         g_variant_unref(gvar_opts);
 403                         return true;
 404                 }
 405         }
 406
 407         g_variant_unref(gvar_opts);
 408
 409         return false;
 410 }
 411
 412 Device::Device(struct sr_dev_inst *structure) :
 413         Configurable(structure->driver, structure, NULL),
 414         _structure(structure)
 415 {
 416         for (GSList *entry = structure->channels; entry; entry = entry->next)
 417         {
 418                 auto channel = (struct sr_channel *) entry->data;
 419                 _channels[channel] = new Channel(channel);
 420         }
 421
 422         for (GSList *entry = structure->channel_groups; entry; entry = entry->next)
 423         {
 424                 auto group = (struct sr_channel_group *) entry->data;
 425                 _channel_groups[group->name] = new ChannelGroup(this, group);
 426         }
 427 }
 428
 429 Device::~Device()
 430 {
 431         for (auto entry : _channels)
 432                 delete entry.second;
 433         for (auto entry : _channel_groups)
 434                 delete entry.second;
 435 }
 436
 437 string Device::description()
 438 {
 439         ostringstream s;
 440
 441         vector<string> parts =
 442                 {vendor(), model(), version()};
 443
 444         for (string part : parts)
 445                 if (part.length() > 0)
 446                         s << part;
 447
 448         return s.str();
 449 }
 450
 451 string Device::vendor()
 452 {
 453         return valid_string(_structure->vendor);
 454 }
 455
 456 string Device::model()
 457 {
 458         return valid_string(_structure->model);
 459 }
 460
 461 string Device::version()
 462 {
 463         return valid_string(_structure->version);
 464 }
 465
 466 vector<shared_ptr<Channel>> Device::channels()
 467 {
 468         vector<shared_ptr<Channel>> result;
 469         for (auto channel = _structure->channels; channel; channel = channel->next)
 470                 result.push_back(
 471                         _channels[(struct sr_channel *) channel->data]->get_shared_pointer(
 472                                 get_shared_from_this()));
 473         return result;
 474 }
 475
 476 shared_ptr<Channel> Device::get_channel(struct sr_channel *ptr)
 477 {
 478         return _channels[ptr]->get_shared_pointer(get_shared_from_this());
 479 }
 480
 481 map<string, shared_ptr<ChannelGroup>>
 482 Device::channel_groups()
 483 {
 484         map<string, shared_ptr<ChannelGroup>> result;
 485         for (auto entry: _channel_groups)
 486         {
 487                 auto name = entry.first;
 488                 auto channel_group = entry.second;
 489                 result[name] = channel_group->get_shared_pointer(get_shared_from_this());
 490         }
 491         return result;
 492 }
 493
 494 void Device::open()
 495 {
 496         check(sr_dev_open(_structure));
 497 }
 498
 499 void Device::close()
 500 {
 501         check(sr_dev_close(_structure));
 502 }
 503
 504 HardwareDevice::HardwareDevice(Driver *driver, struct sr_dev_inst *structure) :
 505         ParentOwned(structure),
 506         Device(structure),
 507         _driver(driver)
 508 {
 509 }
 510
 511 HardwareDevice::~HardwareDevice()
 512 {
 513 }
 514
 515 shared_ptr<Device> HardwareDevice::get_shared_from_this()
 516 {
 517         return static_pointer_cast<Device>(shared_from_this());
 518 }
 519
 520 shared_ptr<Driver> HardwareDevice::driver()
 521 {
 522         return _driver->get_shared_pointer(_parent);
 523 }
 524
 525 Channel::Channel(struct sr_channel *structure) :
 526         ParentOwned(structure),
 527         _type(ChannelType::get(_structure->type))
 528 {
 529 }
 530
 531 Channel::~Channel()
 532 {
 533 }
 534
 535 string Channel::name()
 536 {
 537         return valid_string(_structure->name);
 538 }
 539
 540 void Channel::set_name(string name)
 541 {
 542         check(sr_dev_channel_name_set(_parent->_structure,
 543                 _structure->index, name.c_str()));
 544 }
 545
 546 const ChannelType *Channel::type()
 547 {
 548         return ChannelType::get(_structure->type);
 549 }
 550
 551 bool Channel::enabled()
 552 {
 553         return _structure->enabled;
 554 }
 555
 556 void Channel::set_enabled(bool value)
 557 {
 558         check(sr_dev_channel_enable(_parent->_structure, _structure->index, value));
 559 }
 560
 561 unsigned int Channel::index()
 562 {
 563         return _structure->index;
 564 }
 565
 566 ChannelGroup::ChannelGroup(Device *device,
 567                 struct sr_channel_group *structure) :
 568         ParentOwned(structure),
 569         Configurable(device->_structure->driver, device->_structure, structure)
 570 {
 571         for (GSList *entry = structure->channels; entry; entry = entry->next)
 572                 _channels.push_back(device->_channels[(struct sr_channel *)entry->data]);
 573 }
 574
 575 ChannelGroup::~ChannelGroup()
 576 {
 577 }
 578
 579 string ChannelGroup::name()
 580 {
 581         return valid_string(_structure->name);
 582 }
 583
 584 vector<shared_ptr<Channel>> ChannelGroup::channels()
 585 {
 586         vector<shared_ptr<Channel>> result;
 587         for (auto channel : _channels)
 588                 result.push_back(channel->get_shared_pointer(_parent));
 589         return result;
 590 }
 591
 592 Trigger::Trigger(shared_ptr<Context> context, string name) :
 593         UserOwned(sr_trigger_new(name.c_str())),
 594         _context(context)
 595 {
 596         for (auto stage = _structure->stages; stage; stage = stage->next)
 597                 _stages.push_back(
 598                         new TriggerStage((struct sr_trigger_stage *) stage->data));
 599 }
 600
 601 Trigger::~Trigger()
 602 {
 603         for (auto stage: _stages)
 604                 delete stage;
 605
 606         sr_trigger_free(_structure);
 607 }
 608
 609 string Trigger::name()
 610 {
 611         return _structure->name;
 612 }
 613
 614 vector<shared_ptr<TriggerStage>> Trigger::stages()
 615 {
 616         vector<shared_ptr<TriggerStage>> result;
 617         for (auto stage : _stages)
 618                 result.push_back(stage->get_shared_pointer(this));
 619         return result;
 620 }
 621
 622 shared_ptr<TriggerStage> Trigger::add_stage()
 623 {
 624         auto stage = new TriggerStage(sr_trigger_stage_add(_structure));
 625         _stages.push_back(stage);
 626         return stage->get_shared_pointer(this);
 627 }
 628
 629 TriggerStage::TriggerStage(struct sr_trigger_stage *structure) :
 630         ParentOwned(structure)
 631 {
 632 }
 633
 634 TriggerStage::~TriggerStage()
 635 {
 636         for (auto match : _matches)
 637                 delete match;
 638 }
 639
 640 int TriggerStage::number()
 641 {
 642         return _structure->stage;
 643 }
 644
 645 vector<shared_ptr<TriggerMatch>> TriggerStage::matches()
 646 {
 647         vector<shared_ptr<TriggerMatch>> result;
 648         for (auto match : _matches)
 649                 result.push_back(match->get_shared_pointer(this));
 650         return result;
 651 }
 652
 653 void TriggerStage::add_match(shared_ptr<Channel> channel,
 654         const TriggerMatchType *type, float value)
 655 {
 656         check(sr_trigger_match_add(_structure,
 657                 channel->_structure, type->id(), value));
 658         _matches.push_back(new TriggerMatch(
 659                 (struct sr_trigger_match *) g_slist_last(
 660                         _structure->matches)->data, channel));
 661 }
 662
 663 void TriggerStage::add_match(shared_ptr<Channel> channel,
 664         const TriggerMatchType *type)
 665 {
 666         add_match(channel, type, NAN);
 667 }
 668
 669 TriggerMatch::TriggerMatch(struct sr_trigger_match *structure,
 670                 shared_ptr<Channel> channel) :
 671         ParentOwned(structure),
 672         _channel(channel)
 673 {
 674 }
 675
 676 TriggerMatch::~TriggerMatch()
 677 {
 678 }
 679
 680 shared_ptr<Channel> TriggerMatch::channel()
 681 {
 682         return _channel;
 683 }
 684
 685 const TriggerMatchType *TriggerMatch::type()
 686 {
 687         return TriggerMatchType::get(_structure->match);
 688 }
 689
 690 float TriggerMatch::value()
 691 {
 692         return _structure->value;
 693 }
 694
 695 DatafeedCallbackData::DatafeedCallbackData(Session *session,
 696                 DatafeedCallbackFunction callback) :
 697         _callback(callback),
 698         _session(session)
 699 {
 700 }
 701
 702 void DatafeedCallbackData::run(const struct sr_dev_inst *sdi,
 703         const struct sr_datafeed_packet *pkt)
 704 {
 705         auto device = _session->_devices[sdi];
 706         auto packet = shared_ptr<Packet>(new Packet(device, pkt), Packet::Deleter());
 707         _callback(device, packet);
 708 }
 709
 710 SourceCallbackData::SourceCallbackData(shared_ptr<EventSource> source) :
 711         _source(source)
 712 {
 713 }
 714
 715 bool SourceCallbackData::run(int revents)
 716 {
 717         return _source->_callback((Glib::IOCondition) revents);
 718 }
 719
 720 shared_ptr<EventSource> EventSource::create(int fd, Glib::IOCondition events,
 721         int timeout, SourceCallbackFunction callback)
 722 {
 723         auto result = new EventSource(timeout, callback);
 724         result->_type = EventSource::SOURCE_FD;
 725         result->_fd = fd;
 726         result->_events = events;
 727         return shared_ptr<EventSource>(result, EventSource::Deleter());
 728 }
 729
 730 shared_ptr<EventSource> EventSource::create(Glib::PollFD pollfd, int timeout,
 731         SourceCallbackFunction callback)
 732 {
 733         auto result = new EventSource(timeout, callback);
 734         result->_type = EventSource::SOURCE_POLLFD;
 735         result->_pollfd = pollfd;
 736         return shared_ptr<EventSource>(result, EventSource::Deleter());
 737 }
 738
 739 shared_ptr<EventSource> EventSource::create(Glib::RefPtr<Glib::IOChannel> channel,
 740         Glib::IOCondition events, int timeout, SourceCallbackFunction callback)
 741 {
 742         auto result = new EventSource(timeout, callback);
 743         result->_type = EventSource::SOURCE_IOCHANNEL;
 744         result->_channel = channel;
 745         result->_events = events;
 746         return shared_ptr<EventSource>(result, EventSource::Deleter());
 747 }
 748
 749 EventSource::EventSource(int timeout, SourceCallbackFunction callback) :
 750         _timeout(timeout),
 751         _callback(callback)
 752 {
 753 }
 754
 755 EventSource::~EventSource()
 756 {
 757 }
 758
 759 SessionDevice::SessionDevice(struct sr_dev_inst *structure) :
 760         ParentOwned(structure),
 761         Device(structure)
 762 {
 763 }
 764
 765 SessionDevice::~SessionDevice()
 766 {
 767 }
 768
 769 shared_ptr<Device> SessionDevice::get_shared_from_this()
 770 {
 771         return static_pointer_cast<Device>(shared_from_this());
 772 }
 773
 774 Session::Session(shared_ptr<Context> context) :
 775         UserOwned(_structure),
 776         _context(context),
 777         _saving(false)
 778 {
 779         check(sr_session_new(&_structure));
 780         _context->_session = this;
 781 }
 782
 783 Session::Session(shared_ptr<Context> context, string filename) :
 784         UserOwned(_structure),
 785         _context(context),
 786         _saving(false)
 787 {
 788         check(sr_session_load(filename.c_str(), &_structure));
 789         GSList *dev_list;
 790         check(sr_session_dev_list(_structure, &dev_list));
 791         for (GSList *dev = dev_list; dev; dev = dev->next)
 792         {
 793                 auto sdi = (struct sr_dev_inst *) dev->data;
 794                 auto device = new SessionDevice(sdi);
 795                 _devices[sdi] = shared_ptr<SessionDevice>(device,
 796                         SessionDevice::Deleter());
 797         }
 798         _context->_session = this;
 799 }
 800
 801 Session::~Session()
 802 {
 803         check(sr_session_destroy(_structure));
 804
 805         for (auto callback : _datafeed_callbacks)
 806                 delete callback;
 807
 808         for (auto entry : _source_callbacks)
 809                 delete entry.second;
 810 }
 811
 812 void Session::add_device(shared_ptr<Device> device)
 813 {
 814         check(sr_session_dev_add(_structure, device->_structure));
 815         _devices[device->_structure] = device;
 816 }
 817
 818 vector<shared_ptr<Device>> Session::devices()
 819 {
 820         GSList *dev_list;
 821         check(sr_session_dev_list(_structure, &dev_list));
 822         vector<shared_ptr<Device>> result;
 823         for (GSList *dev = dev_list; dev; dev = dev->next)
 824         {
 825                 auto sdi = (struct sr_dev_inst *) dev->data;
 826                 result.push_back(_devices[sdi]);
 827         }
 828         return result;
 829 }
 830
 831 void Session::remove_devices()
 832 {
 833         _devices.clear();
 834         check(sr_session_dev_remove_all(_structure));
 835 }
 836
 837 void Session::start()
 838 {
 839         check(sr_session_start(_structure));
 840 }
 841
 842 void Session::run()
 843 {
 844         check(sr_session_run(_structure));
 845 }
 846
 847 void Session::stop()
 848 {
 849         check(sr_session_stop(_structure));
 850 }
 851
 852 void Session::begin_save(string filename)
 853 {
 854         _saving = true;
 855         _save_initialized = false;
 856         _save_filename = filename;
 857         _save_samplerate = 0;
 858 }
 859
 860 void Session::append(shared_ptr<Packet> packet)
 861 {
 862         if (!_saving)
 863                 throw Error(SR_ERR);
 864
 865         switch (packet->_structure->type)
 866         {
 867                 case SR_DF_META:
 868                 {
 869                         auto meta = (const struct sr_datafeed_meta *)
 870                                 packet->_structure->payload;
 871
 872                         for (auto l = meta->config; l; l = l->next)
 873                         {
 874                                 auto config = (struct sr_config *) l->data;
 875                                 if (config->key == SR_CONF_SAMPLERATE)
 876                                         _save_samplerate = g_variant_get_uint64(config->data);
 877                         }
 878
 879                         break;
 880                 }
 881                 case SR_DF_LOGIC:
 882                 {
 883                         if (_save_samplerate == 0)
 884                         {
 885                                 GVariant *samplerate;
 886
 887                                 check(sr_config_get(packet->_device->_structure->driver,
 888                                         packet->_device->_structure, NULL, SR_CONF_SAMPLERATE,
 889                                         &samplerate));
 890
 891                                 _save_samplerate = g_variant_get_uint64(samplerate);
 892
 893                                 g_variant_unref(samplerate);
 894                         }
 895
 896                         if (!_save_initialized)
 897                         {
 898                                 vector<shared_ptr<Channel>> save_channels;
 899
 900                                 for (auto channel : packet->_device->channels())
 901                                         if (channel->_structure->enabled &&
 902                                                         channel->_structure->type == SR_CHANNEL_LOGIC)
 903                                                 save_channels.push_back(channel);
 904
 905                                 auto channels = g_new(char *, save_channels.size());
 906
 907                                 int i = 0;
 908                                 for (auto channel : save_channels)
 909                                                 channels[i++] = channel->_structure->name;
 910                                 channels[i] = NULL;
 911
 912                                 int ret = sr_session_save_init(_structure, _save_filename.c_str(),
 913                                                 _save_samplerate, channels);
 914
 915                                 g_free(channels);
 916
 917                                 if (ret != SR_OK)
 918                                         throw Error(ret);
 919
 920                                 _save_initialized = true;
 921                         }
 922
 923                         auto logic = (const struct sr_datafeed_logic *)
 924                                 packet->_structure->payload;
 925
 926                         check(sr_session_append(_structure, _save_filename.c_str(),
 927                                 (uint8_t *) logic->data, logic->unitsize,
 928                                 logic->length / logic->unitsize));
 929                 }
 930         }
 931 }
 932
 933 void Session::append(void *data, size_t length, unsigned int unit_size)
 934 {
 935         check(sr_session_append(_structure, _save_filename.c_str(),
 936                 (uint8_t *) data, unit_size, length));
 937 }
 938
 939 static void datafeed_callback(const struct sr_dev_inst *sdi,
 940         const struct sr_datafeed_packet *pkt, void *cb_data)
 941 {
 942         auto callback = static_cast<DatafeedCallbackData *>(cb_data);
 943         callback->run(sdi, pkt);
 944 }
 945
 946 void Session::add_datafeed_callback(DatafeedCallbackFunction callback)
 947 {
 948         auto cb_data = new DatafeedCallbackData(this, callback);
 949         check(sr_session_datafeed_callback_add(_structure,
 950                 datafeed_callback, cb_data));
 951         _datafeed_callbacks.push_back(cb_data);
 952 }
 953
 954 void Session::remove_datafeed_callbacks(void)
 955 {
 956         check(sr_session_datafeed_callback_remove_all(_structure));
 957         for (auto callback : _datafeed_callbacks)
 958                 delete callback;
 959         _datafeed_callbacks.clear();
 960 }
 961
 962 static int source_callback(int fd, int revents, void *cb_data)
 963 {
 964         (void) fd;
 965         auto callback = (SourceCallbackData *) cb_data;
 966         return callback->run(revents);
 967 }
 968
 969 void Session::add_source(shared_ptr<EventSource> source)
 970 {
 971         if (_source_callbacks.count(source) == 1)
 972                 throw Error(SR_ERR_ARG);
 973
 974         auto cb_data = new SourceCallbackData(source);
 975
 976         switch (source->_type)
 977         {
 978                 case EventSource::SOURCE_FD:
 979                         check(sr_session_source_add(_structure, source->_fd, source->_events,
 980                                 source->_timeout, source_callback, cb_data));
 981                         break;
 982                 case EventSource::SOURCE_POLLFD:
 983                         check(sr_session_source_add_pollfd(_structure,
 984                                 source->_pollfd.gobj(), source->_timeout, source_callback,
 985                                 cb_data));
 986                         break;
 987                 case EventSource::SOURCE_IOCHANNEL:
 988                         check(sr_session_source_add_channel(_structure,
 989                                 source->_channel->gobj(), source->_events, source->_timeout,
 990                                 source_callback, cb_data));
 991                         break;
 992         }
 993
 994         _source_callbacks[source] = cb_data;
 995 }
 996
 997 void Session::remove_source(shared_ptr<EventSource> source)
 998 {
 999         if (_source_callbacks.count(source) == 0)
1000                 throw Error(SR_ERR_ARG);
1001
1002         switch (source->_type)
1003         {
1004                 case EventSource::SOURCE_FD:
1005                         check(sr_session_source_remove(_structure, source->_fd));
1006                         break;
1007                 case EventSource::SOURCE_POLLFD:
1008                         check(sr_session_source_remove_pollfd(_structure,
1009                                 source->_pollfd.gobj()));
1010                         break;
1011                 case EventSource::SOURCE_IOCHANNEL:
1012                         check(sr_session_source_remove_channel(_structure,
1013                                 source->_channel->gobj()));
1014                         break;
1015         }
1016
1017         delete _source_callbacks[source];
1018
1019         _source_callbacks.erase(source);
1020 }
1021
1022 shared_ptr<Trigger> Session::trigger()
1023 {
1024         return _trigger;
1025 }
1026
1027 void Session::set_trigger(shared_ptr<Trigger> trigger)
1028 {
1029         check(sr_session_trigger_set(_structure, trigger->_structure));
1030         _trigger = trigger;
1031 }
1032
1033 Packet::Packet(shared_ptr<Device> device,
1034         const struct sr_datafeed_packet *structure) :
1035         UserOwned(structure),
1036         _device(device)
1037 {
1038         switch (structure->type)
1039         {
1040                 case SR_DF_HEADER:
1041                         _payload = new Header(
1042                                 static_cast<const struct sr_datafeed_header *>(
1043                                         structure->payload));
1044                         break;
1045                 case SR_DF_META:
1046                         _payload = new Meta(
1047                                 static_cast<const struct sr_datafeed_meta *>(
1048                                         structure->payload));
1049                         break;
1050                 case SR_DF_LOGIC:
1051                         _payload = new Logic(
1052                                 static_cast<const struct sr_datafeed_logic *>(
1053                                         structure->payload));
1054                         break;
1055                 case SR_DF_ANALOG:
1056                         _payload = new Analog(
1057                                 static_cast<const struct sr_datafeed_analog *>(
1058                                         structure->payload));
1059                         break;
1060                 default:
1061                         _payload = nullptr;
1062                         break;
1063         }
1064 }
1065
1066 Packet::~Packet()
1067 {
1068         if (_payload)
1069                 delete _payload;
1070 }
1071
1072 const PacketType *Packet::type()
1073 {
1074         return PacketType::get(_structure->type);
1075 }
1076
1077 shared_ptr<PacketPayload> Packet::payload()
1078 {
1079         if (_payload)
1080                 return _payload->get_shared_pointer(this);
1081         else
1082                 throw Error(SR_ERR_NA);
1083 }
1084
1085 PacketPayload::PacketPayload()
1086 {
1087 }
1088
1089 PacketPayload::~PacketPayload()
1090 {
1091 }
1092
1093 Header::Header(const struct sr_datafeed_header *structure) :
1094         ParentOwned(structure),
1095         PacketPayload()
1096 {
1097 }
1098
1099 Header::~Header()
1100 {
1101 }
1102
1103 shared_ptr<PacketPayload> Header::get_shared_pointer(Packet *_parent)
1104 {
1105         return static_pointer_cast<PacketPayload>(
1106                 ParentOwned::get_shared_pointer(_parent));
1107 }
1108
1109 int Header::feed_version()
1110 {
1111         return _structure->feed_version;
1112 }
1113
1114 Glib::TimeVal Header::start_time()
1115 {
1116         return Glib::TimeVal(
1117                 _structure->starttime.tv_sec,
1118                 _structure->starttime.tv_usec);
1119 }
1120
1121 Meta::Meta(const struct sr_datafeed_meta *structure) :
1122         ParentOwned(structure),
1123         PacketPayload()
1124 {
1125 }
1126
1127 Meta::~Meta()
1128 {
1129 }
1130
1131 shared_ptr<PacketPayload> Meta::get_shared_pointer(Packet *_parent)
1132 {
1133         return static_pointer_cast<PacketPayload>(
1134                 ParentOwned::get_shared_pointer(_parent));
1135 }
1136
1137 map<const ConfigKey *, Glib::VariantBase> Meta::config()
1138 {
1139         map<const ConfigKey *, Glib::VariantBase> result;
1140         for (auto l = _structure->config; l; l = l->next)
1141         {
1142                 auto config = (struct sr_config *) l->data;
1143                 result[ConfigKey::get(config->key)] = Glib::VariantBase(config->data);
1144         }
1145         return result;
1146 }
1147
1148 Logic::Logic(const struct sr_datafeed_logic *structure) :
1149         ParentOwned(structure),
1150         PacketPayload()
1151 {
1152 }
1153
1154 Logic::~Logic()
1155 {
1156 }
1157
1158 shared_ptr<PacketPayload> Logic::get_shared_pointer(Packet *_parent)
1159 {
1160         return static_pointer_cast<PacketPayload>(
1161                 ParentOwned::get_shared_pointer(_parent));
1162 }
1163
1164 void *Logic::data_pointer()
1165 {
1166         return _structure->data;
1167 }
1168
1169 size_t Logic::data_length()
1170 {
1171         return _structure->length;
1172 }
1173
1174 unsigned int Logic::unit_size()
1175 {
1176         return _structure->unitsize;
1177 }
1178
1179 Analog::Analog(const struct sr_datafeed_analog *structure) :
1180         ParentOwned(structure),
1181         PacketPayload()
1182 {
1183 }
1184
1185 Analog::~Analog()
1186 {
1187 }
1188
1189 shared_ptr<PacketPayload> Analog::get_shared_pointer(Packet *_parent)
1190 {
1191         return static_pointer_cast<PacketPayload>(
1192                 ParentOwned::get_shared_pointer(_parent));
1193 }
1194
1195 float *Analog::data_pointer()
1196 {
1197         return _structure->data;
1198 }
1199
1200 unsigned int Analog::num_samples()
1201 {
1202         return _structure->num_samples;
1203 }
1204
1205 vector<shared_ptr<Channel>> Analog::channels()
1206 {
1207         vector<shared_ptr<Channel>> result;
1208         for (auto l = _structure->channels; l; l = l->next)
1209                 result.push_back(_parent->_device->get_channel(
1210                         (struct sr_channel *)l->data));
1211         return result;
1212 }
1213
1214 const Quantity *Analog::mq()
1215 {
1216         return Quantity::get(_structure->mq);
1217 }
1218
1219 const Unit *Analog::unit()
1220 {
1221         return Unit::get(_structure->unit);
1222 }
1223
1224 vector<const QuantityFlag *> Analog::mq_flags()
1225 {
1226         return QuantityFlag::flags_from_mask(_structure->mqflags);
1227 }
1228
1229 InputFormat::InputFormat(const struct sr_input_module *structure) :
1230         ParentOwned(structure)
1231 {
1232 }
1233
1234 InputFormat::~InputFormat()
1235 {
1236 }
1237
1238 string InputFormat::name()
1239 {
1240         return valid_string(sr_input_id_get(_structure));
1241 }
1242
1243 string InputFormat::description()
1244 {
1245         return valid_string(sr_input_description_get(_structure));
1246 }
1247
1248 map<string, shared_ptr<Option>> InputFormat::options()
1249 {
1250         const struct sr_option **options = sr_input_options_get(_structure);
1251         auto option_array = shared_ptr<const struct sr_option *>(
1252                 options, sr_input_options_free);
1253         map<string, shared_ptr<Option>> result;
1254         for (int i = 0; options[i]; i++)
1255                 result[options[i]->id] = shared_ptr<Option>(
1256                         new Option(options[i], option_array), Option::Deleter());
1257         return result;
1258 }
1259
1260 shared_ptr<Input> InputFormat::create_input(
1261         map<string, Glib::VariantBase> options)
1262 {
1263         auto input = sr_input_new(_structure, map_to_hash_variant(options));
1264         if (!input)
1265                 throw Error(SR_ERR_ARG);
1266         return shared_ptr<Input>(
1267                 new Input(_parent->shared_from_this(), input), Input::Deleter());
1268 }
1269
1270 Input::Input(shared_ptr<Context> context, const struct sr_input *structure) :
1271         UserOwned(structure),
1272         _context(context),
1273         _device(nullptr)
1274 {
1275 }
1276
1277 shared_ptr<InputDevice> Input::device()
1278 {
1279         if (!_device)
1280         {
1281                 auto sdi = sr_input_dev_inst_get(_structure);
1282                 if (!sdi)
1283                         throw Error(SR_ERR_NA);
1284                 _device = new InputDevice(shared_from_this(), sdi);
1285         }
1286
1287         return _device->get_shared_pointer(shared_from_this());
1288 }
1289
1290 void Input::send(string data)
1291 {
1292         auto gstr = g_string_new(data.c_str());
1293         auto ret = sr_input_send(_structure, gstr);
1294         g_string_free(gstr, false);
1295         check(ret);
1296 }
1297
1298 Input::~Input()
1299 {
1300         if (_device)
1301                 delete _device;
1302         check(sr_input_free(_structure));
1303 }
1304
1305 InputDevice::InputDevice(shared_ptr<Input> input,
1306                 struct sr_dev_inst *structure) :
1307         ParentOwned(structure),
1308         Device(structure),
1309         _input(input)
1310 {
1311 }
1312
1313 InputDevice::~InputDevice()
1314 {
1315 }
1316
1317 shared_ptr<Device> InputDevice::get_shared_from_this()
1318 {
1319         return static_pointer_cast<Device>(shared_from_this());
1320 }
1321
1322 Option::Option(const struct sr_option *structure,
1323                 shared_ptr<const struct sr_option *> structure_array) :
1324         UserOwned(structure),
1325         _structure_array(structure_array)
1326 {
1327 }
1328
1329 Option::~Option()
1330 {
1331 }
1332
1333 string Option::id()
1334 {
1335         return valid_string(_structure->id);
1336 }
1337
1338 string Option::name()
1339 {
1340         return valid_string(_structure->name);
1341 }
1342
1343 string Option::description()
1344 {
1345         return valid_string(_structure->desc);
1346 }
1347
1348 Glib::VariantBase Option::default_value()
1349 {
1350         return Glib::VariantBase(_structure->def, true);
1351 }
1352
1353 vector<Glib::VariantBase> Option::values()
1354 {
1355         vector<Glib::VariantBase> result;
1356         for (auto l = _structure->values; l; l = l->next)
1357                 result.push_back(Glib::VariantBase((GVariant *) l->data, true));
1358         return result;
1359 }
1360
1361 OutputFormat::OutputFormat(const struct sr_output_module *structure) :
1362         ParentOwned(structure)
1363 {
1364 }
1365
1366 OutputFormat::~OutputFormat()
1367 {
1368 }
1369
1370 string OutputFormat::name()
1371 {
1372         return valid_string(sr_output_id_get(_structure));
1373 }
1374
1375 string OutputFormat::description()
1376 {
1377         return valid_string(sr_output_description_get(_structure));
1378 }
1379
1380 map<string, shared_ptr<Option>> OutputFormat::options()
1381 {
1382         const struct sr_option **options = sr_output_options_get(_structure);
1383         auto option_array = shared_ptr<const struct sr_option *>(
1384                 options, sr_output_options_free);
1385         map<string, shared_ptr<Option>> result;
1386         for (int i = 0; options[i]; i++)
1387                 result[options[i]->id] = shared_ptr<Option>(
1388                         new Option(options[i], option_array), Option::Deleter());
1389         return result;
1390 }
1391
1392 shared_ptr<Output> OutputFormat::create_output(
1393         shared_ptr<Device> device, map<string, Glib::VariantBase> options)
1394 {
1395         return shared_ptr<Output>(
1396                 new Output(shared_from_this(), device, options),
1397                 Output::Deleter());
1398 }
1399
1400 Output::Output(shared_ptr<OutputFormat> format,
1401                 shared_ptr<Device> device, map<string, Glib::VariantBase> options) :
1402         UserOwned(sr_output_new(format->_structure,
1403                 map_to_hash_variant(options), device->_structure)),
1404         _format(format),
1405         _device(device),
1406         _options(options)
1407 {
1408 }
1409
1410 Output::~Output()
1411 {
1412         check(sr_output_free(_structure));
1413 }
1414
1415 string Output::receive(shared_ptr<Packet> packet)
1416 {
1417         GString *out;
1418         check(sr_output_send(_structure, packet->_structure, &out));
1419         if (out)
1420         {
1421                 auto result = string(out->str, out->str + out->len);
1422                 g_string_free(out, true);
1423                 return result;
1424         }
1425         else
1426         {
1427                 return string();
1428         }
1429 }
1430
1431 #include "enums.cpp"
1432
1433 }