X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=5356433f9027e8fa5298db01dff5256d8a28a674;hp=605cc05c65fd8ab234f5509d5885f30f276f805d;hb=f6b6c9bf50999dc99f9517318ffd3114cae4960f;hpb=558ad6ceb934ab7406d286c1a4ae08da4aba1448 diff --git a/pv/session.cpp b/pv/session.cpp index 605cc05c..5356433f 100644 --- a/pv/session.cpp +++ b/pv/session.cpp @@ -28,6 +28,7 @@ #include #include "devicemanager.hpp" +#include "mainwindow.hpp" #include "session.hpp" #include "data/analog.hpp" @@ -206,7 +207,7 @@ void Session::save_settings(QSettings &settings) const } shared_ptr sessionfile_device = - dynamic_pointer_cast< devices::SessionFile >(device_); + dynamic_pointer_cast(device_); if (sessionfile_device) { settings.setValue("device_type", "sessionfile"); @@ -216,6 +217,16 @@ void Session::save_settings(QSettings &settings) const settings.endGroup(); } + shared_ptr inputfile_device = + dynamic_pointer_cast(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 base : signalbases_) { #ifdef ENABLE_DECODE @@ -289,20 +300,34 @@ void Session::restore_settings(QSettings &settings) 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(device_manager_.context(), + filename.toStdString()); + } + } + + if (device_type == "inputfile") { + settings.beginGroup("device"); + device = make_shared(device_manager_.context(), + settings); + settings.endGroup(); + } - if (QFileInfo(filename).isReadable()) { - device = make_shared(device_manager_.context(), - filename.toStdString()); + if (device) { set_device(device); - // TODO Perform error handling - start_capture([](QString infoMessage) { (void)infoMessage; }); + start_capture([](QString infoMessage) { + // TODO Emulate noquote() + qDebug() << "Session error:" << infoMessage; }); - set_name(QFileInfo(filename).fileName()); + set_name(QString::fromStdString( + dynamic_pointer_cast(device)->display_name(device_manager_))); } } @@ -352,8 +377,7 @@ void Session::select_device(shared_ptr device) else set_default_device(); } catch (const QString &e) { - main_bar_->session_error(tr("Failed to Select Device"), - tr("Failed to Select Device")); + MainWindow::show_session_error(tr("Failed to select device"), e); } } @@ -373,12 +397,13 @@ void Session::set_device(shared_ptr device) name_ = default_name_; name_changed(); - // Remove all stored data + // Remove all stored data and reset all views for (shared_ptr view : views_) { view->clear_signals(); #ifdef ENABLE_DECODE view->clear_decode_signals(); #endif + view->reset_view_state(); } for (const shared_ptr d : all_signal_data_) d->clear(); @@ -401,6 +426,7 @@ void Session::set_device(shared_ptr device) device_->open(); } catch (const QString &e) { device_.reset(); + MainWindow::show_session_error(tr("Failed to open device"), e); } if (device_) { @@ -426,7 +452,7 @@ void Session::set_default_device() // Try and find the demo device and select that by default const auto iter = find_if(devices.begin(), devices.end(), [] (const shared_ptr &d) { - return d->hardware_device()->driver()->name() == "demo"; }); + return d->hardware_device()->driver()->name() == "demo"; }); set_device((iter == devices.end()) ? devices.front() : *iter); } @@ -490,7 +516,7 @@ void Session::load_init_file(const string &file_name, const string &format) [&](const pair > 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; } @@ -509,6 +535,10 @@ void Session::load_file(QString file_name, 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( @@ -521,8 +551,8 @@ void Session::load_file(QString file_name, new devices::SessionFile( device_manager_.context(), file_name.toStdString()))); - } catch (Error e) { - main_bar_->session_error(tr("Failed to load ") + file_name, e.what()); + } catch (Error& e) { + MainWindow::show_session_error(tr("Failed to load ") + file_name, e.what()); set_default_device(); main_bar_->update_device_list(); return; @@ -531,7 +561,7 @@ void Session::load_file(QString file_name, 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()); } @@ -567,6 +597,8 @@ void Session::start_capture(function error_handler) for (const shared_ptr d : all_signal_data_) d->clear(); + trigger_list_.clear(); + // Revert name back to default name (e.g. "Session 1") for real devices // as the (possibly saved) data is gone. File devices keep their name. shared_ptr hw_device = @@ -677,16 +709,27 @@ double Session::get_samplerate() const return samplerate; } -int Session::get_segment_count() const +uint32_t Session::get_segment_count() const { - int min_val = INT_MAX; + uint32_t value = 0; - // Find the lowest common number of segments + // Find the highest number of segments for (shared_ptr data : all_signal_data_) - if (data->get_segment_count() < min_val) - min_val = data->get_segment_count(); + if (data->get_segment_count() > value) + value = data->get_segment_count(); - return (min_val != INT_MAX) ? min_val : 0; + return value; +} + +vector Session::get_triggers(uint32_t segment_id) const +{ + vector result; + + for (pair entry : trigger_list_) + if (entry.first == segment_id) + result.push_back(entry.second); + + return result; } const unordered_set< shared_ptr > Session::signalbases() const @@ -694,6 +737,17 @@ const unordered_set< shared_ptr > Session::signalbases() const return signalbases_; } +bool Session::all_segments_complete(uint32_t segment_id) const +{ + bool all_complete = true; + + for (shared_ptr base : signalbases_) + if (!base->segment_is_complete(segment_id)) + all_complete = false; + + return all_complete; +} + #ifdef ENABLE_DECODE shared_ptr Session::add_decode_signal() { @@ -708,7 +762,7 @@ shared_ptr Session::add_decode_signal() // Add the decode signal to all views for (shared_ptr view : views_) view->add_decode_signal(signal); - } catch (runtime_error e) { + } catch (runtime_error& e) { remove_decode_signal(signal); return nullptr; } @@ -896,7 +950,11 @@ void Session::sample_thread_proc(function error_handler) if (!device_) return; - cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + try { + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + } catch (Error& e) { + cur_samplerate_ = 0; + } out_of_memory_ = false; @@ -906,10 +964,11 @@ void Session::sample_thread_proc(function error_handler) cur_analog_segments_.clear(); } highest_segment_id_ = -1; + frame_began_ = false; try { device_->start(); - } catch (Error e) { + } catch (Error& e) { error_handler(e.what()); return; } @@ -919,7 +978,7 @@ void Session::sample_thread_proc(function error_handler) try { device_->run(); - } catch (Error e) { + } catch (Error& e) { error_handler(e.what()); set_capture_state(Stopped); return; @@ -928,10 +987,8 @@ void Session::sample_thread_proc(function error_handler) set_capture_state(Stopped); // Confirm that SR_DF_END was received - if (cur_logic_segment_) { - qDebug("SR_DF_END was not received."); - assert(false); - } + if (cur_logic_segment_) + qDebug() << "WARNING: SR_DF_END was not received."; // Optimize memory usage free_unused_memory(); @@ -1019,15 +1076,10 @@ void Session::feed_in_meta(shared_ptr meta) 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; } } @@ -1055,7 +1107,24 @@ void Session::feed_in_trigger() } } - trigger_event(sample_count / get_samplerate()); + uint32_t segment_id = 0; // Default segment when no frames are used + + // If a frame began, we'd ideally be able to use the highest segment ID for + // the trigger. However, as new segments are only created when logic or + // analog data comes in, this doesn't work if the trigger appears right + // after the beginning of the frame, before any sample data. + // For this reason, we use highest segment ID + 1 if no sample data came in + // yet and the highest segment ID otherwise. + if (frame_began_) { + segment_id = highest_segment_id_; + if (!cur_logic_segment_ && (cur_analog_segments_.size() == 0)) + segment_id++; + } + + // TODO Create timestamp from segment start time + segment's current sample count + util::Timestamp timestamp = sample_count / get_samplerate(); + trigger_list_.emplace_back(segment_id, timestamp); + trigger_event(segment_id, timestamp); } void Session::feed_in_frame_begin() @@ -1083,16 +1152,24 @@ void Session::feed_in_frame_end() cur_analog_segments_.clear(); } - if (frame_began_) - frame_began_ = false; + frame_began_ = false; signal_segment_completed(); } void Session::feed_in_logic(shared_ptr logic) { + if (logic->data_length() == 0) { + qDebug() << "WARNING: Received logic packet with 0 samples."; + return; + } + if (!cur_samplerate_) - cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + try { + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + } catch (Error& e) { + // Do nothing + } lock_guard lock(data_mutex_); @@ -1109,7 +1186,8 @@ void Session::feed_in_logic(shared_ptr logic) // Create a new data segment cur_logic_segment_ = make_shared( - *logic_data_, logic->unit_size(), cur_samplerate_); + *logic_data_, logic_data_->get_segment_count(), + logic->unit_size(), cur_samplerate_); logic_data_->push_segment(cur_logic_segment_); signal_new_segment(); @@ -1122,17 +1200,24 @@ void Session::feed_in_logic(shared_ptr logic) void Session::feed_in_analog(shared_ptr analog) { + if (analog->num_samples() == 0) { + qDebug() << "WARNING: Received analog packet with 0 samples."; + return; + } + if (!cur_samplerate_) - cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + try { + cur_samplerate_ = device_->read_config(ConfigKey::SAMPLERATE); + } catch (Error& e) { + // Do nothing + } lock_guard lock(data_mutex_); const vector> 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 data(new float[analog->num_samples()]); + unique_ptr data(new float[analog->num_samples() * channels.size()]); analog->get_data_as_float(data.get()); if (signalbases_.empty()) @@ -1162,7 +1247,7 @@ void Session::feed_in_analog(shared_ptr analog) // Create a segment, keep it in the maps of channels segment = make_shared( - *data, cur_samplerate_); + *data, data->get_segment_count(), cur_samplerate_); cur_analog_segments_[channel] = segment; // Push the segment into the analog data. @@ -1174,8 +1259,8 @@ void Session::feed_in_analog(shared_ptr analog) 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) { @@ -1211,7 +1296,7 @@ void Session::data_feed_in(shared_ptr device, case SR_DF_LOGIC: try { feed_in_logic(dynamic_pointer_cast(packet->payload())); - } catch (bad_alloc) { + } catch (bad_alloc&) { out_of_memory_ = true; device_->stop(); } @@ -1220,7 +1305,7 @@ void Session::data_feed_in(shared_ptr device, case SR_DF_ANALOG: try { feed_in_analog(dynamic_pointer_cast(packet->payload())); - } catch (bad_alloc) { + } catch (bad_alloc&) { out_of_memory_ = true; device_->stop(); } @@ -1240,6 +1325,15 @@ void Session::data_feed_in(shared_ptr device, // devices use frames, and for those devices, we need to do it here. { lock_guard lock(data_mutex_); + + if (cur_logic_segment_) + cur_logic_segment_->set_complete(); + + for (auto entry : cur_analog_segments_) { + shared_ptr segment = entry.second; + segment->set_complete(); + } + cur_logic_segment_.reset(); cur_analog_segments_.clear(); }