1 |
# |
---|
2 |
# Copyright (C) 2009, 2011 by Jonathan Woithe |
---|
3 |
# |
---|
4 |
# This file is part of FFADO |
---|
5 |
# FFADO = Free Firewire (pro-)audio drivers for linux |
---|
6 |
# |
---|
7 |
# FFADO is based upon FreeBoB. |
---|
8 |
# |
---|
9 |
# This program is free software: you can redistribute it and/or modify |
---|
10 |
# it under the terms of the GNU General Public License as published by |
---|
11 |
# the Free Software Foundation, either version 2 of the License, or |
---|
12 |
# (at your option) version 3 of the License. |
---|
13 |
# |
---|
14 |
# This program is distributed in the hope that it will be useful, |
---|
15 |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
16 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
17 |
# GNU General Public License for more details. |
---|
18 |
# |
---|
19 |
# You should have received a copy of the GNU General Public License |
---|
20 |
# along with this program. If not, see <http://www.gnu.org/licenses/>. |
---|
21 |
# |
---|
22 |
|
---|
23 |
from PyQt4 import QtGui |
---|
24 |
|
---|
25 |
from PyQt4.QtCore import SIGNAL, SLOT, QObject, Qt, QTimer |
---|
26 |
from PyQt4.QtGui import QWidget, QApplication |
---|
27 |
from ffado.config import * |
---|
28 |
|
---|
29 |
from ffado.widgets.matrixmixer import MatrixMixer |
---|
30 |
|
---|
31 |
import logging |
---|
32 |
log = logging.getLogger('rme') |
---|
33 |
|
---|
34 |
# Model defines. These must agree with what is used in rme_avdevice.h. |
---|
35 |
RME_MODEL_NONE = 0x0000 |
---|
36 |
RME_MODEL_FF800 = 0x0001 |
---|
37 |
RME_MODEL_FF400 = 0x0002 |
---|
38 |
|
---|
39 |
class Rme(QWidget): |
---|
40 |
def __init__(self,parent = None): |
---|
41 |
QWidget.__init__(self,parent) |
---|
42 |
uicLoad("ffado/mixer/rme", self) |
---|
43 |
|
---|
44 |
self.init() |
---|
45 |
|
---|
46 |
def init(self): |
---|
47 |
|
---|
48 |
self.PhantomSwitches={ |
---|
49 |
self.phantom_0: ['/Control/Phantom', 0], |
---|
50 |
self.phantom_1: ['/Control/Phantom', 1], |
---|
51 |
self.phantom_2: ['/Control/Phantom', 2], |
---|
52 |
self.phantom_3: ['/Control/Phantom', 3], |
---|
53 |
} |
---|
54 |
|
---|
55 |
self.Switches={ |
---|
56 |
self.ff400_chan3_opt_instr: ['/Control/Chan3_opt_instr'], |
---|
57 |
self.ff400_chan3_opt_pad: ['/Control/Chan3_opt_pad'], |
---|
58 |
self.ff400_chan4_opt_instr: ['/Control/Chan4_opt_instr'], |
---|
59 |
self.ff400_chan4_opt_pad: ['/Control/Chan4_opt_pad'], |
---|
60 |
|
---|
61 |
self.spdif_output_optical: ['/Control/SPDIF_output_optical', 0], |
---|
62 |
self.spdif_output_emphasis: ['/Control/SPDIF_output_emphasis', 0], |
---|
63 |
self.spdif_output_pro: ['/Control/SPDIF_output_pro', 0], |
---|
64 |
self.spdif_output_nonaudio: ['/Control/SPDIF_output_nonaudio', 0], |
---|
65 |
} |
---|
66 |
|
---|
67 |
self.Radiobuttons={ |
---|
68 |
self.level_in_lo_gain: ['/Control/Input_level', 1], |
---|
69 |
self.level_in_p4dBu: ['/Control/Input_level', 2], |
---|
70 |
self.level_in_m10dBV: ['/Control/Input_level', 3], |
---|
71 |
|
---|
72 |
self.level_out_hi_gain: ['/Control/Output_level', 1], |
---|
73 |
self.level_out_p4dBu: ['/Control/Output_level', 2], |
---|
74 |
self.level_out_m10dBV: ['/Control/Output_level', 3], |
---|
75 |
|
---|
76 |
self.spdif_input_coax: ['/Control/SPDIF_input_mode', 0], |
---|
77 |
self.spdif_input_optical: ['/Control/SPDIF_input_mode', 1], |
---|
78 |
|
---|
79 |
self.phones_hi_gain: ['/Control/Phones_level', 1], |
---|
80 |
self.phones_p4dBu: ['/Control/Phones_level', 2], |
---|
81 |
self.phones_m10dBV: ['/Control/Phones_level', 3], |
---|
82 |
|
---|
83 |
self.clock_mode_autosync: ['/Control/Clock_mode', 1], |
---|
84 |
self.clock_mode_master: ['/Control/Clock_mode', 0], |
---|
85 |
|
---|
86 |
self.sync_ref_wordclk: ['/Control/Sync_ref', 0], |
---|
87 |
self.sync_ref_adat1: ['/Control/Sync_ref', 1], |
---|
88 |
self.sync_ref_adat2: ['/Control/Sync_ref', 2], |
---|
89 |
self.sync_ref_spdif: ['/Control/Sync_ref', 3], |
---|
90 |
self.sync_ref_tco: ['/Control/Sync_ref', 4], |
---|
91 |
} |
---|
92 |
|
---|
93 |
self.Checkboxes={ |
---|
94 |
self.ch1_instr_fuzz: ['/Control/Chan1_instr_opts', 0x04], |
---|
95 |
self.ch1_instr_limiter: ['/Control/Chan1_instr_opts', 0x08], |
---|
96 |
self.ch1_instr_filter: ['/Control/Chan1_instr_opts', 0x02], |
---|
97 |
} |
---|
98 |
|
---|
99 |
self.Gains={ |
---|
100 |
self.gain_mic1: ['/Control/Gains', 0], |
---|
101 |
self.gain_mic2: ['/Control/Gains', 1], |
---|
102 |
self.gain_input3: ['/Control/Gains', 2], |
---|
103 |
self.gain_input4: ['/Control/Gains', 3], |
---|
104 |
} |
---|
105 |
|
---|
106 |
self.Combos={ |
---|
107 |
self.ff800_ch1_src: ['/Control/Chan1_source'], |
---|
108 |
self.ff800_ch7_src: ['/Control/Chan7_source'], |
---|
109 |
self.ff800_ch8_src: ['/Control/Chan8_source'], |
---|
110 |
} |
---|
111 |
|
---|
112 |
# Other mixer variables |
---|
113 |
self.is_streaming = 0 |
---|
114 |
self.sample_rate = 0 |
---|
115 |
self.model = 0 |
---|
116 |
self.tco_present = 0 |
---|
117 |
|
---|
118 |
# Public slot: update phantom power hardware switches |
---|
119 |
def updatePhantomSwitch(self, a0): |
---|
120 |
sender = self.sender() |
---|
121 |
# Value is the phantom switch value, with a corresponding enable |
---|
122 |
# bit in the high 16 bit word |
---|
123 |
val = (a0 << self.PhantomSwitches[sender][1]) | (0x00010000 << self.PhantomSwitches[sender][1]) |
---|
124 |
log.debug("phantom switch %d set to %d" % (self.PhantomSwitches[sender][1], a0)) |
---|
125 |
self.hw.setDiscrete(self.PhantomSwitches[sender][0], val) |
---|
126 |
|
---|
127 |
# Public slot: update generic switches |
---|
128 |
def updateSwitch(self, a0): |
---|
129 |
sender = self.sender() |
---|
130 |
log.debug("switch %s set to %d" % (self.Switches[sender][0], a0)) |
---|
131 |
self.hw.setDiscrete(self.Switches[sender][0], a0) |
---|
132 |
|
---|
133 |
# Public slot: update generic radiobuttons |
---|
134 |
def updateRadiobutton(self, a0): |
---|
135 |
sender = self.sender() |
---|
136 |
if (a0 != 0): |
---|
137 |
# Only change the control state on a button being "checked" |
---|
138 |
log.debug("radiobutton group %s set to %d" % (self.Radiobuttons[sender][0], self.Radiobuttons[sender][1])) |
---|
139 |
self.hw.setDiscrete(self.Radiobuttons[sender][0], self.Radiobuttons[sender][1]) |
---|
140 |
|
---|
141 |
def updateCheckboxes(self, a0): |
---|
142 |
sender = self.sender() |
---|
143 |
val = self.hw.getDiscrete(self.Checkboxes[sender][0]); |
---|
144 |
if (a0 != 0): |
---|
145 |
val = val | self.Checkboxes[sender][1] |
---|
146 |
else: |
---|
147 |
val = val & ~self.Checkboxes[sender][1] |
---|
148 |
log.debug("checkbox group %s set to %d" % (self.Checkboxes[sender][0], val)); |
---|
149 |
self.hw.setDiscrete(self.Checkboxes[sender][0], val) |
---|
150 |
|
---|
151 |
# Public slot: update gains |
---|
152 |
def updateGain(self, a0): |
---|
153 |
sender = self.sender() |
---|
154 |
log.debug("gain %s[%d] set to %d" % (self.Gains[sender][0], self.Gains[sender][1], a0)) |
---|
155 |
self.hw.setMatrixMixerValue(self.Gains[sender][0], 0, self.Gains[sender][1], a0) |
---|
156 |
|
---|
157 |
def updateBandwidthLimit(self, a0): |
---|
158 |
# Account for the "No ADAT-2" item which will not be present on |
---|
159 |
# a FF400. |
---|
160 |
if (self.model==RME_MODEL_FF400 and a0>0): |
---|
161 |
a0 = a0 + 1 |
---|
162 |
# log.debug("limit update: %d" % (a0)); |
---|
163 |
self.hw.setDiscrete('/Control/Bandwidth_limit', a0); |
---|
164 |
|
---|
165 |
def updateCombo(self, a0): |
---|
166 |
sender = self.sender() |
---|
167 |
log.debug("combo %s set to %d" % (self.Combos[sender][0], a0)) |
---|
168 |
self.hw.setDiscrete(self.Combos[sender][0], a0) |
---|
169 |
|
---|
170 |
def updateStreamingState(self): |
---|
171 |
ss = self.streamingstatus.selected() |
---|
172 |
ss_txt = self.streamingstatus.getEnumLabel(ss) |
---|
173 |
if ss_txt != 'Idle': |
---|
174 |
self.is_streaming = True |
---|
175 |
else: |
---|
176 |
self.is_streaming = False |
---|
177 |
if (self.last_streaming_state != self.is_streaming): |
---|
178 |
self.bandwidth_limit.setEnabled(not(self.is_streaming)); |
---|
179 |
self.last_streaming_state = self.is_streaming |
---|
180 |
|
---|
181 |
def status_update(self): |
---|
182 |
# log.debug("timer event") |
---|
183 |
self.updateStreamingState() |
---|
184 |
clk_mode = ['Master', 'Slave'] |
---|
185 |
src_str = ['None', 'ADAT 1', 'ADAT 2', 'SPDIF', 'Wordclock', 'TCO'] |
---|
186 |
sync_stat = ['No lock', 'Locked', 'Synced'] |
---|
187 |
sysclock_mode = self.hw.getDiscrete('/Control/sysclock_mode') |
---|
188 |
sysclock_freq = self.hw.getDiscrete('/Control/sysclock_freq') |
---|
189 |
autosync_freq = self.hw.getDiscrete('/Control/autosync_freq') |
---|
190 |
autosync_src = self.hw.getDiscrete('/Control/autosync_src') |
---|
191 |
sync_status = self.hw.getDiscrete('/Control/sync_status') |
---|
192 |
spdif_freq = self.hw.getDiscrete('/Control/spdif_freq') |
---|
193 |
self.sysclock_freq.setText("%d Hz" % (sysclock_freq)) |
---|
194 |
self.sysclock_mode.setText(clk_mode[sysclock_mode]) |
---|
195 |
self.autosync_freq.setText("%d Hz" % (autosync_freq)) |
---|
196 |
self.autosync_src.setText(src_str[autosync_src]) |
---|
197 |
self.sync_check_adat1_status.setText(sync_stat[sync_status & 0x03]) |
---|
198 |
self.sync_check_adat2_status.setText(sync_stat[(sync_status >> 2) & 0x03]) |
---|
199 |
self.sync_check_spdif_status.setText(sync_stat[(sync_status >> 4) & 0x03]) |
---|
200 |
self.sync_check_wclk_status.setText(sync_stat[(sync_status >> 6) & 0x03]) |
---|
201 |
self.sync_check_tco_status.setText(sync_stat[(sync_status >> 8) & 0x03]) |
---|
202 |
self.spdif_freq.setText("%d Hz" % (spdif_freq)) |
---|
203 |
|
---|
204 |
# Hide and disable a control |
---|
205 |
def disable_hide(self,widget): |
---|
206 |
widget.hide() |
---|
207 |
widget.setEnabled(False) |
---|
208 |
|
---|
209 |
def initValues(self): |
---|
210 |
|
---|
211 |
# print self.hw.servername |
---|
212 |
# print self.hw.basepath |
---|
213 |
self.inputmatrix = MatrixMixer(self.hw.servername, self.hw.basepath+"/Mixer/InputFaders", self, 0x8000, self.hw.basepath+"/Mixer/InputMutes", self.hw.basepath+"/Mixer/InputInverts") |
---|
214 |
layout = QtGui.QVBoxLayout() |
---|
215 |
scrollarea = QtGui.QScrollArea() |
---|
216 |
scrollarea.setWidgetResizable(True) |
---|
217 |
scrollarea.setWidget(self.inputmatrix) |
---|
218 |
layout.addWidget(scrollarea) |
---|
219 |
self.mixer.setLayout(layout) |
---|
220 |
|
---|
221 |
self.playbackmatrix = MatrixMixer(self.hw.servername, self.hw.basepath+"/Mixer/PlaybackFaders", self, 0x8000, self.hw.basepath+"/Mixer/PlaybackMutes", self.hw.basepath+"/Mixer/PlaybackInverts") |
---|
222 |
layout = QtGui.QVBoxLayout() |
---|
223 |
scrollarea = QtGui.QScrollArea() |
---|
224 |
scrollarea.setWidgetResizable(True) |
---|
225 |
scrollarea.setWidget(self.playbackmatrix) |
---|
226 |
layout.addWidget(scrollarea) |
---|
227 |
self.playbackmixer.setLayout(layout) |
---|
228 |
|
---|
229 |
self.outputmatrix = MatrixMixer(self.hw.servername, self.hw.basepath+"/Mixer/OutputFaders", self, 0x8000, self.hw.basepath+"/Mixer/OutputMutes") |
---|
230 |
layout = QtGui.QVBoxLayout() |
---|
231 |
scrollarea = QtGui.QScrollArea() |
---|
232 |
scrollarea.setWidgetResizable(True) |
---|
233 |
scrollarea.setWidget(self.outputmatrix) |
---|
234 |
layout.addWidget(scrollarea) |
---|
235 |
self.outputmixer.setLayout(layout) |
---|
236 |
|
---|
237 |
self.is_streaming = False |
---|
238 |
self.last_streaming_state = False |
---|
239 |
|
---|
240 |
# Retrieve other device settings as needed and customise the UI |
---|
241 |
# based on these options. |
---|
242 |
self.model = self.hw.getDiscrete('/Control/Model') |
---|
243 |
log.debug("device model identifier: %d" % (self.model)) |
---|
244 |
self.tco_present = self.hw.getDiscrete('/Control/TCO_present') |
---|
245 |
log.debug("device has TCO: %d" % (self.tco_present)) |
---|
246 |
#self.sample_rate = self.hw.getDiscrete('/Mixer/Info/SampleRate') |
---|
247 |
#log.debug("device sample rate: %d" % (self.sample_rate)) |
---|
248 |
|
---|
249 |
# The Fireface-400 only has 2 phantom-capable channels |
---|
250 |
if (self.model == RME_MODEL_FF400): |
---|
251 |
self.disable_hide(self.phantom_2) |
---|
252 |
self.disable_hide(self.phantom_3) |
---|
253 |
else: |
---|
254 |
self.phantom_0.setText("Mic 7") |
---|
255 |
self.phantom_1.setText("Mic 8") |
---|
256 |
self.phantom_2.setText("Mic 9") |
---|
257 |
self.phantom_3.setText("Mic 10") |
---|
258 |
|
---|
259 |
# Instrument options, input jack selection controls and an ADAT2 |
---|
260 |
# input are applicable only to the FF800 |
---|
261 |
if (self.model != RME_MODEL_FF800): |
---|
262 |
self.instrument_options_group.setEnabled(False) |
---|
263 |
self.input_plug_select_group.setEnabled(False) |
---|
264 |
self.sync_ref_adat2.setEnabled(False) |
---|
265 |
self.sync_check_adat2_label.setEnabled(False) |
---|
266 |
self.sync_check_adat2_status.setEnabled(False) |
---|
267 |
|
---|
268 |
for ctrl, info in self.Combos.iteritems(): |
---|
269 |
if (not(ctrl.isEnabled())): |
---|
270 |
continue; |
---|
271 |
val = self.hw.getDiscrete(info[0]) |
---|
272 |
log.debug("combo %s is %d" % (info[0], val)); |
---|
273 |
ctrl.setCurrentIndex(val); |
---|
274 |
QObject.connect(ctrl, SIGNAL('currentIndexChanged(int)'), self.updateCombo) |
---|
275 |
|
---|
276 |
if (not(self.tco_present)): |
---|
277 |
self.sync_check_tco_label.setEnabled(False) |
---|
278 |
self.sync_check_tco_status.setEnabled(False) |
---|
279 |
self.sync_ref_tco.setEnabled(False) |
---|
280 |
|
---|
281 |
# Only the FF400 has specific channel 3/4 options, input gain |
---|
282 |
# controls and switchable phones level |
---|
283 |
if (self.model != RME_MODEL_FF400): |
---|
284 |
self.disable_hide(self.input_gains_group) |
---|
285 |
self.disable_hide(self.channel_3_4_options_group) |
---|
286 |
self.phones_level_group.setEnabled(False) |
---|
287 |
|
---|
288 |
# Add the "No ADAT-2" item to the bandwidth limit control if the |
---|
289 |
# device is not a FF400. Set the control to reflect the current |
---|
290 |
# device setting and connect an update signal. |
---|
291 |
if (self.model != RME_MODEL_FF400): |
---|
292 |
self.bandwidth_limit.insertItem(1, "No ADAT-2") |
---|
293 |
val = self.hw.getDiscrete('/Control/Bandwidth_limit') |
---|
294 |
if (self.model==RME_MODEL_FF400 and val>1): |
---|
295 |
val = val - 1 |
---|
296 |
self.bandwidth_limit.setCurrentIndex(val); |
---|
297 |
QObject.connect(self.bandwidth_limit, SIGNAL('currentIndexChanged(int)'), self.updateBandwidthLimit) |
---|
298 |
|
---|
299 |
# Get current hardware values and connect GUI element signals to |
---|
300 |
# their respective slots |
---|
301 |
for ctrl, info in self.PhantomSwitches.iteritems(): |
---|
302 |
if (not(ctrl.isEnabled())): |
---|
303 |
continue |
---|
304 |
val = (self.hw.getDiscrete(info[0]) >> info[1]) & 0x01 |
---|
305 |
log.debug("phantom switch %d is %d" % (info[1], val)) |
---|
306 |
if val: |
---|
307 |
ctrl.setChecked(True) |
---|
308 |
else: |
---|
309 |
ctrl.setChecked(False) |
---|
310 |
QObject.connect(ctrl, SIGNAL('toggled(bool)'), self.updatePhantomSwitch) |
---|
311 |
|
---|
312 |
for ctrl, info in self.Switches.iteritems(): |
---|
313 |
if (not(ctrl.isEnabled())): |
---|
314 |
continue |
---|
315 |
val = self.hw.getDiscrete(info[0]) |
---|
316 |
log.debug("switch %s is %d" % (info[0], val)) |
---|
317 |
if val: |
---|
318 |
ctrl.setChecked(True) |
---|
319 |
else: |
---|
320 |
ctrl.setChecked(False) |
---|
321 |
QObject.connect(ctrl, SIGNAL('toggled(bool)'), self.updateSwitch) |
---|
322 |
|
---|
323 |
for ctrl, info in self.Radiobuttons.iteritems(): |
---|
324 |
if (not(ctrl.isEnabled())): |
---|
325 |
continue; |
---|
326 |
# This is a touch wasteful since it means we retrieve the control |
---|
327 |
# value once per radio button rather than once per radio button |
---|
328 |
# group. In time we might introduce radiobutton groupings in the |
---|
329 |
# self.* datastructures to avoid this, but for the moment this is |
---|
330 |
# easy and it works. |
---|
331 |
val = self.hw.getDiscrete(info[0]) |
---|
332 |
if (val == info[1]): |
---|
333 |
val = 1 |
---|
334 |
else: |
---|
335 |
val = 0 |
---|
336 |
ctrl.setChecked(val) |
---|
337 |
log.debug("Radiobutton %s[%d] is %d" % (info[0], info[1], val)) |
---|
338 |
QObject.connect(ctrl, SIGNAL('toggled(bool)'), self.updateRadiobutton) |
---|
339 |
|
---|
340 |
for ctrl, info in self.Checkboxes.iteritems(): |
---|
341 |
if (not(ctrl.isEnabled())): |
---|
342 |
continue; |
---|
343 |
# This is a touch wasteful since it means we retrieve the control |
---|
344 |
# value once per checkbox button rather than once per checkbox |
---|
345 |
# group. In time we might introduce checkbox groupings in the |
---|
346 |
# self.* datastructures to avoid this, but for the moment this is |
---|
347 |
# easy and it works. |
---|
348 |
val = self.hw.getDiscrete(info[0]) |
---|
349 |
if (val & info[1]): |
---|
350 |
val = 1 |
---|
351 |
else: |
---|
352 |
val = 0 |
---|
353 |
ctrl.setChecked(val) |
---|
354 |
log.debug("Checkbox %s[%d] is %d" % (info[0], info[1], val)) |
---|
355 |
QObject.connect(ctrl, SIGNAL('toggled(bool)'), self.updateCheckboxes) |
---|
356 |
|
---|
357 |
for ctrl, info in self.Gains.iteritems(): |
---|
358 |
if (not(ctrl.isEnabled())): |
---|
359 |
continue |
---|
360 |
val = self.hw.getMatrixMixerValue(info[0], 0, info[1]) |
---|
361 |
log.debug("gain %s[%d] is %d" % (info[0], info[1], val)) |
---|
362 |
ctrl.setValue(val); |
---|
363 |
QObject.connect(ctrl, SIGNAL('valueChanged(int)'), self.updateGain) |
---|
364 |
|
---|
365 |
self.updateStreamingState() |
---|
366 |
#log.debug("device streaming flag: %d" % (self.is_streaming)) |
---|
367 |
|
---|
368 |
self.update_timer = QTimer(self) |
---|
369 |
QObject.connect(self.update_timer, SIGNAL('timeout()'), self.status_update) |
---|
370 |
self.update_timer.start(1000) |
---|
371 |
|
---|
372 |
# vim: et |
---|