#include <sys/stat.h>
#include "devicemanager.hpp"
+#include "mainwindow.hpp"
#include "session.hpp"
#include "data/analog.hpp"
}
shared_ptr<devices::SessionFile> sessionfile_device =
- dynamic_pointer_cast< devices::SessionFile >(device_);
+ dynamic_pointer_cast<devices::SessionFile>(device_);
if (sessionfile_device) {
settings.setValue("device_type", "sessionfile");
settings.endGroup();
}
+ shared_ptr<devices::InputFile> inputfile_device =
+ dynamic_pointer_cast<devices::InputFile>(device_);
+
+ if (inputfile_device) {
+ settings.setValue("device_type", "inputfile");
+ settings.beginGroup("device");
+ inputfile_device->save_meta_to_settings(settings);
+ settings.endGroup();
+ }
+
// Save channels and decoders
for (shared_ptr<data::SignalBase> base : signalbases_) {
#ifdef ENABLE_DECODE
settings.endGroup();
}
- if (device_type == "sessionfile") {
- settings.beginGroup("device");
- QString filename = settings.value("filename").toString();
- settings.endGroup();
+ if ((device_type == "sessionfile") || (device_type == "inputfile")) {
+ if (device_type == "sessionfile") {
+ settings.beginGroup("device");
+ QString filename = settings.value("filename").toString();
+ settings.endGroup();
- if (QFileInfo(filename).isReadable()) {
- device = make_shared<devices::SessionFile>(device_manager_.context(),
- filename.toStdString());
+ if (QFileInfo(filename).isReadable()) {
+ device = make_shared<devices::SessionFile>(device_manager_.context(),
+ filename.toStdString());
+ }
+ }
+
+ if (device_type == "inputfile") {
+ settings.beginGroup("device");
+ device = make_shared<devices::InputFile>(device_manager_.context(),
+ settings);
+ settings.endGroup();
+ }
+
+ if (device) {
set_device(device);
start_capture([](QString infoMessage) {
- qDebug().noquote() << "Session error:" << infoMessage; });
+ // TODO Emulate noquote()
+ qDebug() << "Session error:" << infoMessage; });
- set_name(QFileInfo(filename).fileName());
+ set_name(QString::fromStdString(
+ dynamic_pointer_cast<devices::File>(device)->display_name(device_manager_)));
}
}
else
set_default_device();
} catch (const QString &e) {
- main_bar_->session_error(tr("Failed to select device"), e);
+ MainWindow::show_session_error(tr("Failed to select device"), e);
}
}
name_ = default_name_;
name_changed();
- // Remove all stored data
+ // Remove all stored data and reset all views
for (shared_ptr<views::ViewBase> view : views_) {
view->clear_signals();
#ifdef ENABLE_DECODE
view->clear_decode_signals();
#endif
+ view->reset_view_state();
}
for (const shared_ptr<data::SignalData> d : all_signal_data_)
d->clear();
device_->open();
} catch (const QString &e) {
device_.reset();
- main_bar_->session_error(tr("Failed to open device"), e);
+ MainWindow::show_session_error(tr("Failed to open device"), e);
}
if (device_) {
[&](const pair<string, shared_ptr<InputFormat> > f) {
return f.first == user_name; });
if (iter == formats.end()) {
- main_bar_->session_error(tr("Error"),
+ MainWindow::show_session_error(tr("Error"),
tr("Unexpected input format: %s").arg(QString::fromStdString(format)));
return;
}
const QString errorMessage(
QString("Failed to load file %1").arg(file_name));
+ // In the absence of a caller's format spec, try to auto detect.
+ // Assume "sigrok session file" upon lookup miss.
+ if (!format)
+ format = device_manager_.context()->input_format_match(file_name.toStdString());
try {
if (format)
set_device(shared_ptr<devices::Device>(
device_manager_.context(),
file_name.toStdString())));
} catch (Error& e) {
- main_bar_->session_error(tr("Failed to load ") + file_name, e.what());
+ MainWindow::show_session_error(tr("Failed to load ") + file_name, e.what());
set_default_device();
main_bar_->update_device_list();
return;
main_bar_->update_device_list();
start_capture([&, errorMessage](QString infoMessage) {
- main_bar_->session_error(errorMessage, infoMessage); });
+ MainWindow::show_session_error(errorMessage, infoMessage); });
set_name(QFileInfo(file_name).fileName());
}
if (!device_)
return;
- cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
+ try {
+ cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
+ } catch (Error& e) {
+ cur_samplerate_ = 0;
+ }
out_of_memory_ = false;
for (auto entry : meta->config()) {
switch (entry.first->id()) {
case SR_CONF_SAMPLERATE:
- // We can't rely on the header to always contain the sample rate,
- // so in case it's supplied via a meta packet, we use it.
- if (!cur_samplerate_)
- cur_samplerate_ = g_variant_get_uint64(entry.second.gobj());
-
- /// @todo handle samplerate changes
+ cur_samplerate_ = g_variant_get_uint64(entry.second.gobj());
break;
default:
- // Unknown metadata is not an error.
+ qDebug() << "Received meta data key" << entry.first->id() << ", ignoring.";
break;
}
}
}
if (!cur_samplerate_)
- cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
+ try {
+ cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
+ } catch (Error& e) {
+ // Do nothing
+ }
lock_guard<recursive_mutex> lock(data_mutex_);
}
if (!cur_samplerate_)
- cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
+ try {
+ cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
+ } catch (Error& e) {
+ // Do nothing
+ }
lock_guard<recursive_mutex> lock(data_mutex_);
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;
bool sweep_beginning = false;
- unique_ptr<float[]> data(new float[analog->num_samples()]);
+ unique_ptr<float[]> data(new float[analog->num_samples() * channels.size()]);
analog->get_data_as_float(data.get());
if (signalbases_.empty())
assert(segment);
// Append the samples in the segment
- segment->append_interleaved_samples(channel_data++, sample_count,
- channel_count);
+ segment->append_interleaved_samples(channel_data++, analog->num_samples(),
+ channels.size());
}
if (sweep_beginning) {