#include <QFileInfo>
#include <cassert>
+#include <memory>
#include <mutex>
#include <stdexcept>
#include "toolbars/mainbar.hpp"
-#include "view/analogsignal.hpp"
-#include "view/decodetrace.hpp"
-#include "view/logicsignal.hpp"
-#include "view/signal.hpp"
-#include "view/view.hpp"
+#include "views/trace/analogsignal.hpp"
+#include "views/trace/decodetrace.hpp"
+#include "views/trace/logicsignal.hpp"
+#include "views/trace/signal.hpp"
+#include "views/trace/view.hpp"
#include <libsigrokcxx/libsigrokcxx.hpp>
using std::runtime_error;
using std::shared_ptr;
using std::string;
+using std::unique_ptr;
using std::unordered_set;
using std::vector;
set_device((iter == devices.end()) ? devices.front() : *iter);
}
+/**
+ * Convert generic options to data types that are specific to InputFormat.
+ *
+ * @param[in] user_spec Vector of tokenized words, string format.
+ * @param[in] fmt_opts Input format's options, result of InputFormat::options().
+ *
+ * @return Map of options suitable for InputFormat::create_input().
+ */
+map<string, Glib::VariantBase>
+Session::input_format_options(vector<string> user_spec,
+ map<string, shared_ptr<Option>> fmt_opts)
+{
+ map<string, Glib::VariantBase> result;
+
+ for (auto entry : user_spec) {
+ /*
+ * Split key=value specs. Accept entries without separator
+ * (for simplified boolean specifications).
+ */
+ string key, val;
+ size_t pos = entry.find("=");
+ if (pos == std::string::npos) {
+ key = entry;
+ val = "";
+ } else {
+ key = entry.substr(0, pos);
+ val = entry.substr(pos + 1);
+ }
+
+ /*
+ * Skip user specifications that are not a member of the
+ * format's set of supported options. Have the text input
+ * spec converted to the required input format specific
+ * data type.
+ */
+ auto found = fmt_opts.find(key);
+ if (found == fmt_opts.end())
+ continue;
+ shared_ptr<Option> opt = found->second;
+ result[key] = opt->parse_string(val);
+ }
+
+ return result;
+}
+
void Session::load_init_file(const string &file_name, const string &format)
{
shared_ptr<InputFormat> input_format;
+ map<string, Glib::VariantBase> input_opts;
if (!format.empty()) {
const map<string, shared_ptr<InputFormat> > formats =
device_manager_.context()->input_formats();
+ auto user_opts = pv::util::split_string(format, ":");
+ string user_name = user_opts.front();
+ user_opts.erase(user_opts.begin());
const auto iter = find_if(formats.begin(), formats.end(),
[&](const pair<string, shared_ptr<InputFormat> > f) {
- return f.first == format; });
+ return f.first == user_name; });
if (iter == formats.end()) {
main_bar_->session_error(tr("Error"),
tr("Unexpected input format: %s").arg(QString::fromStdString(format)));
return;
}
-
input_format = (*iter).second;
+ input_opts = input_format_options(user_opts,
+ input_format->options());
}
- load_file(QString::fromStdString(file_name), input_format);
+ load_file(QString::fromStdString(file_name), input_format, input_opts);
}
void Session::load_file(QString file_name,
// Make the signals list
for (shared_ptr<views::ViewBase> viewbase : views_) {
- views::TraceView::View *trace_view =
- qobject_cast<views::TraceView::View*>(viewbase.get());
+ views::trace::View *trace_view =
+ qobject_cast<views::trace::View*>(viewbase.get());
if (trace_view) {
- unordered_set< shared_ptr<views::TraceView::Signal> >
+ unordered_set< shared_ptr<views::trace::Signal> >
prev_sigs(trace_view->signals());
trace_view->clear_signals();
for (auto channel : sr_dev->channels()) {
shared_ptr<data::SignalBase> signalbase;
- shared_ptr<views::TraceView::Signal> signal;
+ shared_ptr<views::trace::Signal> signal;
// Find the channel in the old signals
const auto iter = find_if(
prev_sigs.cbegin(), prev_sigs.cend(),
- [&](const shared_ptr<views::TraceView::Signal> &s) {
+ [&](const shared_ptr<views::trace::Signal> &s) {
return s->base()->channel() == channel;
});
if (iter != prev_sigs.end()) {
signalbase.get(), SLOT(on_capture_state_changed(int)));
}
- signal = shared_ptr<views::TraceView::Signal>(
- new views::TraceView::LogicSignal(*this,
+ signal = shared_ptr<views::trace::Signal>(
+ new views::trace::LogicSignal(*this,
device_, signalbase));
trace_view->add_signal(signal);
break;
signalbase.get(), SLOT(on_capture_state_changed(int)));
}
- signal = shared_ptr<views::TraceView::Signal>(
- new views::TraceView::AnalogSignal(
+ signal = shared_ptr<views::trace::Signal>(
+ new views::trace::AnalogSignal(
*this, signalbase));
trace_view->add_signal(signal);
break;
set_capture_state(device_->session()->trigger() ?
AwaitingTrigger : Running);
- device_->run();
+ try {
+ device_->run();
+ } catch (Error e) {
+ error_handler(e.what());
+ set_capture_state(Stopped);
+ return;
+ }
+
set_capture_state(Stopped);
// Confirm that SR_DF_END was received
const vector<shared_ptr<Channel>> channels = analog->channels();
const unsigned int channel_count = channels.size();
const size_t sample_count = analog->num_samples() / channel_count;
- const float *data = static_cast<const float *>(analog->data_pointer());
bool sweep_beginning = false;
+ unique_ptr<float> data(new float[analog->num_samples()]);
+ analog->get_data_as_float(data.get());
+
if (signalbases_.empty())
update_signals();
+ float *channel_data = data.get();
for (auto channel : channels) {
shared_ptr<data::AnalogSegment> segment;
assert(segment);
// Append the samples in the segment
- segment->append_interleaved_samples(data++, sample_count,
+ segment->append_interleaved_samples(channel_data++, sample_count,
channel_count);
}
projects / pulseview.git / blobdiff