Implemented a global decode lock to prevent concurrent decode
[pulseview.git] / pv / toolbars / samplingbar.cpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2012 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 #include <extdef.h>
22
23 #include <assert.h>
24
25 #include <boost/foreach.hpp>
26
27 #include <libsigrok/libsigrok.h>
28
29 #include <QAction>
30 #include <QDebug>
31
32 #include "samplingbar.h"
33
34 #include <pv/devicemanager.h>
35 #include <pv/popups/deviceoptions.h>
36
37 using namespace std;
38
39 namespace pv {
40 namespace toolbars {
41
42 const uint64_t SamplingBar::RecordLengths[20] = {
43         1000,
44         2500,
45         5000,
46         10000,
47         25000,
48         50000,
49         100000,
50         250000,
51         500000,
52         1000000,
53         2000000,
54         5000000,
55         10000000,
56         25000000,
57         50000000,
58         100000000,
59         250000000,
60         500000000,
61         1000000000,
62         10000000000ULL,
63 };
64
65 const uint64_t SamplingBar::DefaultRecordLength = 1000000;
66
67 SamplingBar::SamplingBar(SigSession &session, QWidget *parent) :
68         QToolBar("Sampling Bar", parent),
69         _session(session),
70         _device_selector(this),
71         _updating_device_selector(false),
72         _configure_button(this),
73         _probes_button(this),
74         _probes_popup(_session, this),
75         _record_length_selector(this),
76         _sample_rate_list(this),
77         _icon_red(":/icons/status-red.svg"),
78         _icon_green(":/icons/status-green.svg"),
79         _icon_grey(":/icons/status-grey.svg"),
80         _run_stop_button(this)
81 {
82         connect(&_run_stop_button, SIGNAL(clicked()),
83                 this, SLOT(on_run_stop()));
84         connect(&_device_selector, SIGNAL(currentIndexChanged (int)),
85                 this, SLOT(on_device_selected()));
86
87         _sample_rate_value.setDecimals(0);
88         _sample_rate_value.setSuffix("Hz");
89
90         for (size_t i = 0; i < countof(RecordLengths); i++)
91         {
92                 const uint64_t &l = RecordLengths[i];
93                 char *const text = sr_si_string_u64(l, " samples");
94                 _record_length_selector.addItem(QString(text),
95                         qVariantFromValue(l));
96                 g_free(text);
97
98                 if (l == DefaultRecordLength)
99                         _record_length_selector.setCurrentIndex(i);
100         }
101
102         set_capture_state(pv::SigSession::Stopped);
103
104         _configure_button.setIcon(QIcon::fromTheme("configure",
105                 QIcon(":/icons/configure.png")));
106
107         _probes_button.setIcon(QIcon::fromTheme("probes",
108                 QIcon(":/icons/probes.svg")));
109         _probes_button.set_popup(&_probes_popup);
110
111         _run_stop_button.setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
112
113         addWidget(&_device_selector);
114         addWidget(&_configure_button);
115         addWidget(&_probes_button);
116         addWidget(&_record_length_selector);
117         _sample_rate_list_action = addWidget(&_sample_rate_list);
118         _sample_rate_value_action = addWidget(&_sample_rate_value);
119         addWidget(&_run_stop_button);
120
121         connect(&_sample_rate_list, SIGNAL(currentIndexChanged(int)),
122                 this, SLOT(on_sample_rate_changed()));
123         connect(&_sample_rate_value, SIGNAL(editingFinished()),
124                 this, SLOT(on_sample_rate_changed()));
125 }
126
127 void SamplingBar::set_device_list(
128         const std::list<struct sr_dev_inst*> &devices)
129 {
130         _updating_device_selector = true;
131
132         _device_selector.clear();
133
134         BOOST_FOREACH (sr_dev_inst *sdi, devices) {
135                 const string title = DeviceManager::format_device_title(sdi);
136                 _device_selector.addItem(title.c_str(),
137                         qVariantFromValue((void*)sdi));
138         }
139
140         _updating_device_selector = false;
141
142         on_device_selected();
143 }
144
145 struct sr_dev_inst* SamplingBar::get_selected_device() const
146 {
147         const int index = _device_selector.currentIndex();
148         if (index < 0)
149                 return NULL;
150
151         return (sr_dev_inst*)_device_selector.itemData(
152                 index).value<void*>();
153 }
154
155 void SamplingBar::set_selected_device(struct sr_dev_inst *const sdi)
156 {
157         for (int i = 0; i < _device_selector.count(); i++)
158                 if (sdi == _device_selector.itemData(i).value<void*>()) {
159                         _device_selector.setCurrentIndex(i);
160                         return;
161                 }
162 }
163
164 uint64_t SamplingBar::get_record_length() const
165 {
166         const int index = _record_length_selector.currentIndex();
167         if (index < 0)
168                 return 0;
169
170         return _record_length_selector.itemData(index).value<uint64_t>();
171 }
172
173 void SamplingBar::set_capture_state(pv::SigSession::capture_state state)
174 {
175         const QIcon *icons[] = {&_icon_grey, &_icon_red, &_icon_green};
176         _run_stop_button.setIcon(*icons[state]);
177         _run_stop_button.setText((state == pv::SigSession::Stopped) ?
178                 tr("Run") : tr("Stop"));
179 }
180
181 void SamplingBar::update_sample_rate_selector()
182 {
183         const sr_dev_inst *const sdi = get_selected_device();
184         GVariant *gvar_dict, *gvar_list;
185         const uint64_t *elements = NULL;
186         gsize num_elements;
187         QAction *selector_action = NULL;
188
189         assert(_sample_rate_value_action);
190         assert(_sample_rate_list_action);
191
192         if (!sdi)
193                 return;
194
195         if (sr_config_list(sdi->driver, SR_CONF_SAMPLERATE,
196                         &gvar_dict, sdi) != SR_OK)
197                 return;
198
199         _sample_rate_list_action->setVisible(false);
200         _sample_rate_value_action->setVisible(false);
201
202         if ((gvar_list = g_variant_lookup_value(gvar_dict,
203                         "samplerate-steps", G_VARIANT_TYPE("at")))) {
204                 elements = (const uint64_t *)g_variant_get_fixed_array(
205                                 gvar_list, &num_elements, sizeof(uint64_t));
206                 _sample_rate_value.setRange(elements[0], elements[1]);
207                 _sample_rate_value.setSingleStep(elements[2]);
208                 g_variant_unref(gvar_list);
209
210                 selector_action = _sample_rate_value_action;
211         }
212         else if ((gvar_list = g_variant_lookup_value(gvar_dict,
213                         "samplerates", G_VARIANT_TYPE("at"))))
214         {
215                 elements = (const uint64_t *)g_variant_get_fixed_array(
216                                 gvar_list, &num_elements, sizeof(uint64_t));
217                 _sample_rate_list.clear();
218
219                 for (unsigned int i = 0; i < num_elements; i++)
220                 {
221                         char *const s = sr_samplerate_string(elements[i]);
222                         _sample_rate_list.addItem(QString(s),
223                                 qVariantFromValue(elements[i]));
224                         g_free(s);
225                 }
226
227                 _sample_rate_list.show();
228                 g_variant_unref(gvar_list);
229
230                 selector_action = _sample_rate_list_action;
231         }
232
233         g_variant_unref(gvar_dict);
234         update_sample_rate_selector_value();
235
236         // We delay showing the action, so that value change events
237         // are ignored.
238         if (selector_action)
239                 selector_action->setVisible(true);
240 }
241
242 void SamplingBar::update_sample_rate_selector_value()
243 {
244         sr_dev_inst *const sdi = get_selected_device();
245         GVariant *gvar;
246         uint64_t samplerate;
247
248         assert(sdi);
249
250         if (sr_config_get(sdi->driver, SR_CONF_SAMPLERATE,
251                 &gvar, sdi) != SR_OK) {
252                 qDebug() <<
253                                 "WARNING: Failed to get value of sample rate";
254                 return;
255         }
256         samplerate = g_variant_get_uint64(gvar);
257         g_variant_unref(gvar);
258
259         assert(_sample_rate_value_action);
260         assert(_sample_rate_list_action);
261
262         if (_sample_rate_value_action->isVisible())
263                 _sample_rate_value.setValue(samplerate);
264         else if (_sample_rate_list_action->isVisible())
265         {
266                 for (int i = 0; i < _sample_rate_list.count(); i++)
267                         if (samplerate == _sample_rate_list.itemData(
268                                 i).value<uint64_t>())
269                                 _sample_rate_list.setCurrentIndex(i);
270         }
271 }
272
273 void SamplingBar::commit_sample_rate()
274 {
275         uint64_t sample_rate = 0;
276
277         sr_dev_inst *const sdi = get_selected_device();
278         assert(sdi);
279
280         assert(_sample_rate_value_action);
281         assert(_sample_rate_list_action);
282
283         if (_sample_rate_value_action->isVisible())
284                 sample_rate = (uint64_t)_sample_rate_value.value();
285         else if (_sample_rate_list_action->isVisible())
286         {
287                 const int index = _sample_rate_list.currentIndex();
288                 if (index >= 0)
289                         sample_rate = _sample_rate_list.itemData(
290                                 index).value<uint64_t>();
291         }
292
293         if (sample_rate == 0)
294                 return;
295
296         // Set the samplerate
297         if (sr_config_set(sdi, SR_CONF_SAMPLERATE,
298                 g_variant_new_uint64(sample_rate)) != SR_OK) {
299                 qDebug() << "Failed to configure samplerate.";
300                 return;
301         }
302 }
303
304 void SamplingBar::on_device_selected()
305 {
306         using namespace pv::popups;
307
308         if (_updating_device_selector)
309                 return;
310
311         update_sample_rate_selector();
312
313         sr_dev_inst *const sdi = get_selected_device();
314         _session.set_device(sdi);
315
316         _configure_button.set_popup(new DeviceOptions(sdi, this));
317 }
318
319 void SamplingBar::on_sample_rate_changed()
320 {
321         commit_sample_rate();
322 }
323
324 void SamplingBar::on_run_stop()
325 {
326         commit_sample_rate();   
327         run_stop();
328 }
329
330 } // namespace toolbars
331 } // namespace pv