Session: Don't process packets without sample data

[pulseview.git] / pv / session.cpp

diff --git a/pv/session.cpp b/pv/session.cpp
index ca72e9b0d670fed6a14da47d4c7c2ce79946c078..cbf24e235acc274c478c79481bfc5b446c80939f 100644 (file)
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -299,8 +299,8 @@ void Session::restore_settings(QSettings &settings)
                                filename.toStdString());
                        set_device(device);
 
-                       // TODO Perform error handling
-                       start_capture([](QString infoMessage) { (void)infoMessage; });
+                       start_capture([](QString infoMessage) {
+                               qDebug().noquote() << "Session error:" << infoMessage; });
 
                        set_name(QFileInfo(filename).fileName());
                }
@@ -352,8 +352,7 @@ void Session::select_device(shared_ptr<devices::Device> device)
                else
                        set_default_device();
        } catch (const QString &e) {
-               main_bar_->session_error(tr("Failed to Select Device"),
-                       tr("Failed to Select Device"));
+               main_bar_->session_error(tr("Failed to select device"), e);
        }
 }
 
@@ -401,6 +400,7 @@ void Session::set_device(shared_ptr<devices::Device> device)
                device_->open();
        } catch (const QString &e) {
                device_.reset();
+               main_bar_->session_error(tr("Failed to open device"), e);
        }
 
        if (device_) {
@@ -426,7 +426,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<devices::HardwareDevice> &d) {
-                       return d->hardware_device()->driver()->name() == "demo";        });
+                       return d->hardware_device()->driver()->name() == "demo"; });
        set_device((iter == devices.end()) ? devices.front() : *iter);
 }
 
@@ -521,7 +521,7 @@ void Session::load_file(QString file_name,
                                new devices::SessionFile(
                                        device_manager_.context(),
                                        file_name.toStdString())));
-       } catch (Error e) {
+       } catch (Error& e) {
                main_bar_->session_error(tr("Failed to load ") + file_name, e.what());
                set_default_device();
                main_bar_->update_device_list();
@@ -732,7 +732,7 @@ shared_ptr<data::DecodeSignal> Session::add_decode_signal()
                // Add the decode signal to all views
                for (shared_ptr<views::ViewBase> view : views_)
                        view->add_decode_signal(signal);
-       } catch (runtime_error e) {
+       } catch (runtime_error& e) {
                remove_decode_signal(signal);
                return nullptr;
        }
@@ -934,7 +934,7 @@ void Session::sample_thread_proc(function<void (const QString)> error_handler)
 
        try {
                device_->start();
-       } catch (Error e) {
+       } catch (Error& e) {
                error_handler(e.what());
                return;
        }
@@ -944,7 +944,7 @@ void Session::sample_thread_proc(function<void (const QString)> error_handler)
 
        try {
                device_->run();
-       } catch (Error e) {
+       } catch (Error& e) {
                error_handler(e.what());
                set_capture_state(Stopped);
                return;
@@ -953,10 +953,8 @@ void Session::sample_thread_proc(function<void (const QString)> 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();
@@ -1080,10 +1078,21 @@ void Session::feed_in_trigger()
                }
        }
 
-       // If no frame began then this is a trigger for a new segment
-       const uint32_t segment_id =
-               (frame_began_) ? highest_segment_id_ : (highest_segment_id_ + 1);
+       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);
@@ -1121,6 +1130,11 @@ void Session::feed_in_frame_end()
 
 void Session::feed_in_logic(shared_ptr<Logic> logic)
 {
+       if (logic->data_length() == 0) {
+               qDebug() << "WARNING: Received logic packet with 0 samples.";
+               return;
+       }
+
        if (!cur_samplerate_)
                cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
 
@@ -1153,6 +1167,11 @@ void Session::feed_in_logic(shared_ptr<Logic> logic)
 
 void Session::feed_in_analog(shared_ptr<Analog> analog)
 {
+       if (analog->num_samples() == 0) {
+               qDebug() << "WARNING: Received analog packet with 0 samples.";
+               return;
+       }
+
        if (!cur_samplerate_)
                cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
 
@@ -1242,7 +1261,7 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
        case SR_DF_LOGIC:
                try {
                        feed_in_logic(dynamic_pointer_cast<Logic>(packet->payload()));
-               } catch (bad_alloc) {
+               } catch (bad_alloc&) {
                        out_of_memory_ = true;
                        device_->stop();
                }
@@ -1251,7 +1270,7 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
        case SR_DF_ANALOG:
                try {
                        feed_in_analog(dynamic_pointer_cast<Analog>(packet->payload()));
-               } catch (bad_alloc) {
+               } catch (bad_alloc&) {
                        out_of_memory_ = true;
                        device_->stop();
                }
@@ -1271,6 +1290,15 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
                // devices use frames, and for those devices, we need to do it here.
                {
                        lock_guard<recursive_mutex> lock(data_mutex_);
+
+                       if (cur_logic_segment_)
+                               cur_logic_segment_->set_complete();
+
+                       for (auto entry : cur_analog_segments_) {
+                               shared_ptr<data::AnalogSegment> segment = entry.second;
+                               segment->set_complete();
+                       }
+
                        cur_logic_segment_.reset();
                        cur_analog_segments_.clear();
                }