MainBar: Catch errors listing the config keys
[pulseview.git] / pv / session.hpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2012-14 Joel Holdsworth <joel@airwebreathe.org.uk>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  */
20
21 #ifndef PULSEVIEW_PV_SESSION_HPP
22 #define PULSEVIEW_PV_SESSION_HPP
23
24 #include <map>
25 #include <memory>
26 #include <mutex>
27 #include <set>
28 #include <string>
29 #include <thread>
30 #include <unordered_set>
31 #include <vector>
32
33 #ifdef _WIN32
34 // Windows: Avoid namespace pollution by thread.hpp (which includes windows.h).
35 #define NOGDI
36 #define NORESOURCE
37 #endif
38 #include <boost/thread.hpp>
39
40 #include <QObject>
41 #include <QString>
42
43 struct srd_decoder;
44 struct srd_channel;
45
46 namespace sigrok {
47 class Analog;
48 class Channel;
49 class Device;
50 class Logic;
51 class Meta;
52 class Packet;
53 class Session;
54 }
55
56 namespace pv {
57
58 class DeviceManager;
59
60 namespace data {
61 class Analog;
62 class AnalogSegment;
63 class Logic;
64 class LogicSegment;
65 class SignalData;
66 }
67
68 namespace devices {
69 class Device;
70 }
71
72 namespace view {
73 class DecodeTrace;
74 class LogicSignal;
75 class Signal;
76 }
77
78 class Session : public QObject
79 {
80         Q_OBJECT
81
82 public:
83         enum capture_state {
84                 Stopped,
85                 AwaitingTrigger,
86                 Running
87         };
88
89 public:
90         Session(DeviceManager &device_manager);
91
92         ~Session();
93
94         DeviceManager& device_manager();
95
96         const DeviceManager& device_manager() const;
97
98         std::shared_ptr<sigrok::Session> session() const;
99
100         std::shared_ptr<devices::Device> device() const;
101
102         /**
103          * Sets device instance that will be used in the next capture session.
104          */
105         void set_device(std::shared_ptr<devices::Device> device);
106
107         void set_default_device();
108
109         capture_state get_capture_state() const;
110
111         void start_capture(std::function<void (const QString)> error_handler);
112
113         void stop_capture();
114
115         std::set< std::shared_ptr<data::SignalData> > get_data() const;
116
117         boost::shared_mutex& signals_mutex() const;
118
119         const std::unordered_set< std::shared_ptr<view::Signal> >&
120                 signals() const;
121
122 #ifdef ENABLE_DECODE
123         bool add_decoder(srd_decoder *const dec);
124
125         std::vector< std::shared_ptr<view::DecodeTrace> >
126                 get_decode_signals() const;
127
128         void remove_decode_signal(view::DecodeTrace *signal);
129 #endif
130
131 private:
132         void set_capture_state(capture_state state);
133
134         void update_signals(std::shared_ptr<devices::Device> device);
135
136         std::shared_ptr<view::Signal> signal_from_channel(
137                 std::shared_ptr<sigrok::Channel> channel) const;
138
139         void read_sample_rate(std::shared_ptr<sigrok::Device> device);
140
141 private:
142         void sample_thread_proc(std::shared_ptr<devices::Device> device,
143                 std::function<void (const QString)> error_handler);
144
145         void feed_in_header();
146
147         void feed_in_meta(std::shared_ptr<sigrok::Meta> meta);
148
149         void feed_in_frame_begin();
150
151         void feed_in_logic(std::shared_ptr<sigrok::Logic> logic);
152
153         void feed_in_analog(std::shared_ptr<sigrok::Analog> analog);
154
155         void data_feed_in(std::shared_ptr<sigrok::Device> device,
156                 std::shared_ptr<sigrok::Packet> packet);
157
158 private:
159         DeviceManager &device_manager_;
160         std::shared_ptr<devices::Device> device_;
161
162         std::vector< std::shared_ptr<view::DecodeTrace> > decode_traces_;
163
164         mutable std::mutex sampling_mutex_;
165         capture_state capture_state_;
166
167         mutable boost::shared_mutex signals_mutex_;
168         std::unordered_set< std::shared_ptr<view::Signal> > signals_;
169
170         mutable std::mutex data_mutex_;
171         std::shared_ptr<data::Logic> logic_data_;
172         uint64_t cur_samplerate_;
173         std::shared_ptr<data::LogicSegment> cur_logic_segment_;
174         std::map< std::shared_ptr<sigrok::Channel>, std::shared_ptr<data::AnalogSegment> >
175                 cur_analog_segments_;
176
177         std::thread sampling_thread_;
178
179 Q_SIGNALS:
180         void capture_state_changed(int state);
181         void device_selected();
182
183         void signals_changed();
184
185         void frame_began();
186
187         void data_received();
188
189         void frame_ended();
190 };
191
192 } // namespace pv
193
194 #endif // PULSEVIEW_PV_SESSION_HPP