X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=df09ff3b2ebc0b924a9158158de9a2362ab385db;hp=3c5bcc426cd750fcca98ab1a56c9b97c70a86009;hb=0a4162a4bd844574319f8b26b05f4fcdf837bb70;hpb=f4e57597347e47a4ea58fbdc7b0a22e07f1c0ede

diff --git a/pv/session.cpp b/pv/session.cpp
index 3c5bcc42..df09ff3b 100644
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -14,8 +14,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifdef _WIN32
@@ -46,6 +45,7 @@
 #include "data/decode/decoder.hpp"
 
 #include "devices/hardwaredevice.hpp"
+#include "devices/inputfile.hpp"
 #include "devices/sessionfile.hpp"
 
 #include "toolbars/mainbar.hpp"
@@ -72,6 +72,7 @@ using std::lock_guard;
 using std::list;
 using std::map;
 using std::mutex;
+using std::pair;
 using std::recursive_mutex;
 using std::set;
 using std::shared_ptr;
@@ -86,8 +87,10 @@ using sigrok::ConfigKey;
 using sigrok::DatafeedCallbackFunction;
 using sigrok::Error;
 using sigrok::Header;
+using sigrok::InputFormat;
 using sigrok::Logic;
 using sigrok::Meta;
+using sigrok::OutputFormat;
 using sigrok::Packet;
 using sigrok::PacketPayload;
 using sigrok::Session;
@@ -102,7 +105,8 @@ Session::Session(DeviceManager &device_manager, QString name) :
 	default_name_(name),
 	name_(name),
 	capture_state_(Stopped),
-	cur_samplerate_(0)
+	cur_samplerate_(0),
+	data_saved_(true)
 {
 }
 
@@ -169,6 +173,11 @@ shared_ptr<pv::toolbars::MainBar> Session::main_bar() const
 	return main_bar_;
 }
 
+bool Session::data_saved() const
+{
+	return data_saved_;
+}
+
 void Session::save_settings(QSettings &settings) const
 {
 	map<string, string> dev_info;
@@ -349,6 +358,19 @@ void Session::restore_settings(QSettings &settings)
 	}
 }
 
+void Session::select_device(shared_ptr<devices::Device> device)
+{
+	try {
+		if (device)
+			set_device(device);
+		else
+			set_default_device();
+	} catch (const QString &e) {
+		main_bar_->session_error(tr("Failed to Select Device"),
+			tr("Failed to Select Device"));
+	}
+}
+
 void Session::set_device(shared_ptr<devices::Device> device)
 {
 	assert(device);
@@ -422,6 +444,63 @@ void Session::set_default_device()
 	set_device((iter == devices.end()) ? devices.front() : *iter);
 }
 
+void Session::load_init_file(const std::string &file_name,
+	const std::string &format)
+{
+	shared_ptr<InputFormat> input_format;
+
+	if (!format.empty()) {
+		const map<string, shared_ptr<InputFormat> > formats =
+			device_manager_.context()->input_formats();
+		const auto iter = find_if(formats.begin(), formats.end(),
+			[&](const pair<string, shared_ptr<InputFormat> > f) {
+				return f.first == format; });
+		if (iter == formats.end()) {
+			main_bar_->session_error(tr("Error"),
+				tr("Unexpected input format: %s").arg(QString::fromStdString(format)));
+			return;
+		}
+
+		input_format = (*iter).second;
+	}
+
+	load_file(QString::fromStdString(file_name), input_format);
+}
+
+void Session::load_file(QString file_name,
+	std::shared_ptr<sigrok::InputFormat> format,
+	const std::map<std::string, Glib::VariantBase> &options)
+{
+	const QString errorMessage(
+		QString("Failed to load file %1").arg(file_name));
+
+	try {
+		if (format)
+			set_device(shared_ptr<devices::Device>(
+				new devices::InputFile(
+					device_manager_.context(),
+					file_name.toStdString(),
+					format, options)));
+		else
+			set_device(shared_ptr<devices::Device>(
+				new devices::SessionFile(
+					device_manager_.context(),
+					file_name.toStdString())));
+	} catch (Error e) {
+		main_bar_->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); });
+
+	set_name(QFileInfo(file_name).fileName());
+}
+
 Session::capture_state Session::get_capture_state() const
 {
 	lock_guard<mutex> lock(sampling_mutex_);
@@ -585,8 +664,12 @@ bool Session::add_decoder(srd_decoder *const dec)
 
 void Session::remove_decode_signal(shared_ptr<data::SignalBase> signalbase)
 {
+	signalbases_.erase(signalbase);
+
 	for (std::shared_ptr<views::ViewBase> view : views_)
 		view->remove_decode_signal(signalbase);
+
+	signals_changed();
 }
 #endif
 
@@ -774,10 +857,31 @@ 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_);
+
+	if (!file_device)
+		data_saved_ = false;
+
 	if (out_of_memory_)
 		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);
@@ -837,8 +941,6 @@ void Session::feed_in_logic(shared_ptr<Logic> logic)
 {
 	lock_guard<recursive_mutex> lock(data_mutex_);
 
-	const size_t sample_count = logic->data_length() / logic->unit_size();
-
 	if (!logic_data_) {
 		// The only reason logic_data_ would not have been created is
 		// if it was not possible to determine the signals when the
@@ -852,8 +954,7 @@ void Session::feed_in_logic(shared_ptr<Logic> logic)
 
 		// Create a new data segment
 		cur_logic_segment_ = shared_ptr<data::LogicSegment>(
-			new data::LogicSegment(
-				logic, cur_samplerate_, sample_count));
+			new data::LogicSegment(logic, cur_samplerate_));
 		logic_data_->push_segment(cur_logic_segment_);
 
 		// @todo Putting this here means that only listeners querying
@@ -898,8 +999,7 @@ void Session::feed_in_analog(shared_ptr<Analog> analog)
 
 			// Create a segment, keep it in the maps of channels
 			segment = shared_ptr<data::AnalogSegment>(
-				new data::AnalogSegment(
-					cur_samplerate_, sample_count));
+				new data::AnalogSegment(cur_samplerate_));
 			cur_analog_segments_[channel] = segment;
 
 			// Find the analog data associated with the channel
@@ -931,6 +1031,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);
@@ -952,6 +1054,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:
@@ -972,6 +1075,7 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
 		}
 		break;
 
+	case SR_DF_FRAME_END:
 	case SR_DF_END:
 	{
 		{
@@ -979,7 +1083,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:
@@ -987,4 +1094,9 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
 	}
 }
 
+void Session::on_data_saved()
+{
+	data_saved_ = true;
+}
+
 } // namespace pv