namespace sigrok
{
+using namespace std;
+
/** Helper function to translate C errors to C++ exceptions. */
static void check(int result)
{
return result;
}
+shared_ptr<InputFormat> Context::input_format_match(string filename)
+{
+ const struct sr_input *input;
+ const struct sr_input_module *imod;
+ int rc;
+
+ /*
+ * Have the input module looked up for the specified file.
+ * Failed lookup (or "successful lookup" with an empty result)
+ * are non-fatal. Free the sr_input that was created by the
+ * lookup routine, but grab the input module kind and return an
+ * InputFormat instance to the application. This works because
+ * the application passes a filename, no input data got buffered
+ * in the sr_input that we release.
+ */
+ input = NULL;
+ rc = sr_input_scan_file(filename.c_str(), &input);
+ if (rc != SR_OK)
+ return nullptr;
+ if (!input)
+ return nullptr;
+ imod = sr_input_module_get(input);
+ sr_input_free(input);
+ return shared_ptr<InputFormat>{new InputFormat{imod}, default_delete<InputFormat>{}};
+}
+
map<string, shared_ptr<OutputFormat>> Context::output_formats()
{
map<string, shared_ptr<OutputFormat>> result;
try {
(*callback)(LogLevel::get(loglevel), message.get());
- } catch (Error e) {
+ } catch (Error &e) {
return e.result;
}
default_delete<UserDevice>{}};
}
-shared_ptr<Packet> Context::create_header_packet(Glib::TimeVal start_time)
+shared_ptr<Packet> Context::create_header_packet(Glib::DateTime start_time)
{
auto header = g_new(struct sr_datafeed_header, 1);
header->feed_version = 1;
- header->starttime.tv_sec = start_time.tv_sec;
- header->starttime.tv_usec = start_time.tv_usec;
+ header->starttime.tv_sec = start_time.to_unix();
+ header->starttime.tv_usec = start_time.get_microsecond();
auto packet = g_new(struct sr_datafeed_packet, 1);
packet->type = SR_DF_HEADER;
packet->payload = header;
return shared_ptr<Packet>{new Packet{nullptr, packet}, default_delete<Packet>{}};
}
+shared_ptr<Packet> Context::create_end_packet()
+{
+ auto packet = g_new(struct sr_datafeed_packet, 1);
+ packet->type = SR_DF_END;
+ return shared_ptr<Packet>{new Packet{nullptr, packet},
+ default_delete<Packet>{}};
+}
+
shared_ptr<Session> Context::load_session(string filename)
{
return shared_ptr<Session>{
_owned_devices.emplace(sdi, move(device));
}
_context->_session = this;
+ g_slist_free(dev_list);
}
Session::~Session()
auto *const sdi = static_cast<struct sr_dev_inst *>(dev->data);
result.push_back(get_device(sdi));
}
+ g_slist_free(dev_list);
return result;
}
return _structure->feed_version;
}
-Glib::TimeVal Header::start_time() const
+Glib::DateTime Header::start_time() const
{
- return Glib::TimeVal(
- _structure->starttime.tv_sec,
- _structure->starttime.tv_usec);
+ Glib::DateTime time = Glib::DateTime::create_now_utc(_structure->starttime.tv_sec);
+ return time.add_seconds(_structure->starttime.tv_usec / 1.0e6);
}
Meta::Meta(const struct sr_datafeed_meta *structure) :
dt = SR_T_FLOAT;
} else if (g_variant_is_of_type(tmpl, G_VARIANT_TYPE_INT32)) {
dt = SR_T_INT32;
+ } else if (g_variant_is_of_type(tmpl, G_VARIANT_TYPE_UINT32)) {
+ dt = SR_T_UINT32;
} else {
throw Error(SR_ERR_BUG);
}
check(sr_output_free(_structure));
}
+shared_ptr<OutputFormat> Output::format()
+{
+ return _format;
+}
+
string Output::receive(shared_ptr<Packet> packet)
{
GString *out;