Prefer std::make_shared().

[pulseview.git] / pv / session.cpp

diff --git a/pv/session.cpp b/pv/session.cpp
index 97741ebf7b944a4c6507bd1a4e64c1d8128a5d5b..ef2f39bb8ed3ddb88ded541959042ad531a5096a 100644 (file)
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -76,6 +76,7 @@ using std::pair;
 using std::recursive_mutex;
 using std::set;
 using std::shared_ptr;
+using std::make_shared;
 using std::string;
 using std::unordered_set;
 using std::vector;
@@ -307,7 +308,7 @@ void Session::restore_settings(QSettings &settings)
                settings.endGroup();
 
                if (QFileInfo(filename).isReadable()) {
-                       device = std::make_shared<devices::SessionFile>(device_manager_.context(),
+                       device = make_shared<devices::SessionFile>(device_manager_.context(),
                                filename.toStdString());
                        set_device(device);
 
@@ -383,7 +384,7 @@ void Session::set_device(shared_ptr<devices::Device> device)
 
        device_.reset();
 
-       // Revert name back to default name (e.g. "Untitled-1") as the data is gone
+       // Revert name back to default name (e.g. "Session 1") as the data is gone
        name_ = default_name_;
        name_changed();
 
@@ -415,16 +416,17 @@ void Session::set_device(shared_ptr<devices::Device> device)
                device_->open();
        } catch (const QString &e) {
                device_.reset();
-               device_changed();
-               throw;
        }
 
-       device_->session()->add_datafeed_callback([=]
-               (shared_ptr<sigrok::Device> device, shared_ptr<Packet> packet) {
-                       data_feed_in(device, packet);
-               });
+       if (device_) {
+               device_->session()->add_datafeed_callback([=]
+                       (shared_ptr<sigrok::Device> device, shared_ptr<Packet> packet) {
+                               data_feed_in(device, packet);
+                       });
+
+               update_signals();
+       }
 
-       update_signals();
        device_changed();
 }
 
@@ -532,7 +534,7 @@ void Session::start_capture(function<void (const QString)> error_handler)
        for (const shared_ptr<data::SignalData> d : all_signal_data_)
                d->clear();
 
-       // Revert name back to default name (e.g. "Untitled-1") as the data is gone
+       // Revert name back to default name (e.g. "Session 1") as the data is gone
        name_ = default_name_;
        name_changed();
 
@@ -616,8 +618,7 @@ bool Session::add_decoder(srd_decoder *const dec)
 
        try {
                // Create the decoder
-               decoder_stack = shared_ptr<data::DecoderStack>(
-                       new data::DecoderStack(*this, dec));
+               decoder_stack = make_shared<data::DecoderStack>(*this, dec);
 
                // Make a list of all the channels
                std::vector<const srd_channel*> all_channels;
@@ -643,7 +644,7 @@ bool Session::add_decoder(srd_decoder *const dec)
 
                // Create the decode signal
                shared_ptr<data::SignalBase> signalbase =
-                       shared_ptr<data::SignalBase>(new data::SignalBase(nullptr));
+                       make_shared<data::SignalBase>(nullptr);
 
                signalbase->set_decoder_stack(decoder_stack);
                signalbases_.insert(signalbase);
@@ -771,8 +772,7 @@ void Session::update_signals()
                                        switch(channel->type()->id()) {
                                        case SR_CHANNEL_LOGIC:
                                                if (!signalbase) {
-                                                       signalbase = shared_ptr<data::SignalBase>(
-                                                               new data::SignalBase(channel));
+                                                       signalbase = make_shared<data::SignalBase>(channel);
                                                        signalbases_.insert(signalbase);
 
                                                        all_signal_data_.insert(logic_data_);
@@ -788,8 +788,7 @@ void Session::update_signals()
                                        case SR_CHANNEL_ANALOG:
                                        {
                                                if (!signalbase) {
-                                                       signalbase = shared_ptr<data::SignalBase>(
-                                                               new data::SignalBase(channel));
+                                                       signalbase = make_shared<data::SignalBase>(channel);
                                                        signalbases_.insert(signalbase);
 
                                                        shared_ptr<data::Analog> data(new data::Analog());
@@ -857,6 +856,9 @@ void Session::sample_thread_proc(function<void (const QString)> error_handler)
                assert(0);
        }
 
+       // Optimize memory usage
+       free_unused_memory();
+
        // We now have unsaved data unless we just "captured" from a file
        shared_ptr<devices::File> file_device =
                dynamic_pointer_cast<devices::File>(device_);
@@ -868,6 +870,17 @@ void Session::sample_thread_proc(function<void (const QString)> error_handler)
                error_handler(tr("Out of memory, acquisition stopped."));
 }
 
+void Session::free_unused_memory()
+{
+       for (shared_ptr<data::SignalData> data : all_signal_data_) {
+               const vector< shared_ptr<data::Segment> > segments = data->segments();
+
+               for (shared_ptr<data::Segment> segment : segments) {
+                       segment->free_unused_memory();
+               }
+       }
+}
+
 void Session::feed_in_header()
 {
        cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
@@ -939,8 +952,8 @@ void Session::feed_in_logic(shared_ptr<Logic> logic)
                set_capture_state(Running);
 
                // Create a new data segment
-               cur_logic_segment_ = shared_ptr<data::LogicSegment>(
-                       new data::LogicSegment(logic, cur_samplerate_));
+               cur_logic_segment_ = make_shared<data::LogicSegment>(
+                       *logic_data_, logic, cur_samplerate_);
                logic_data_->push_segment(cur_logic_segment_);
 
                // @todo Putting this here means that only listeners querying
@@ -983,11 +996,6 @@ void Session::feed_in_analog(shared_ptr<Analog> analog)
                        // in the sweep containing this segment.
                        sweep_beginning = true;
 
-                       // Create a segment, keep it in the maps of channels
-                       segment = shared_ptr<data::AnalogSegment>(
-                               new data::AnalogSegment(cur_samplerate_));
-                       cur_analog_segments_[channel] = segment;
-
                        // Find the analog data associated with the channel
                        shared_ptr<data::SignalBase> base = signalbase_from_channel(channel);
                        assert(base);
@@ -995,6 +1003,11 @@ void Session::feed_in_analog(shared_ptr<Analog> analog)
                        shared_ptr<data::Analog> data(base->analog_data());
                        assert(data);
 
+                       // Create a segment, keep it in the maps of channels
+                       segment = make_shared<data::AnalogSegment>(
+                               *data, cur_samplerate_);
+                       cur_analog_segments_[channel] = segment;
+
                        // Push the segment into the analog data.
                        data->push_segment(segment);
                }
@@ -1017,6 +1030,8 @@ void Session::feed_in_analog(shared_ptr<Analog> analog)
 void Session::data_feed_in(shared_ptr<sigrok::Device> device,
        shared_ptr<Packet> packet)
 {
+       static bool frame_began=false;
+
        (void)device;
 
        assert(device);
@@ -1038,6 +1053,7 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
 
        case SR_DF_FRAME_BEGIN:
                feed_in_frame_begin();
+               frame_began = true;
                break;
 
        case SR_DF_LOGIC:
@@ -1058,6 +1074,7 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
                }
                break;
 
+       case SR_DF_FRAME_END:
        case SR_DF_END:
        {
                {
@@ -1065,7 +1082,10 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
                        cur_logic_segment_.reset();
                        cur_analog_segments_.clear();
                }
-               frame_ended();
+               if (frame_began) {
+                       frame_began = false;
+                       frame_ended();
+               }
                break;
        }
        default: