code.delx.au - pulseaudio/blob - src/utils/qpaeq

   1 #!/usr/bin/env python
   2 #    qpaeq is a equalizer interface for pulseaudio's equalizer sinks
   3 #    Copyright (C) 2009  Jason Newton <nevion@gmail.com
   4 #
   5 #    This program is free software: you can redistribute it and/or modify
   6 #    it under the terms of the GNU Affero General Public License as
   7 #    published by the Free Software Foundation, either version 3 of the
   8 #    License, or (at your option) any later version.
   9 #
  10 #    This program is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU Affero General Public License for more details.
  14 #
  15 #    You should have received a copy of the GNU Affero General Public License
  16 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 import os,math,sys
  20 try:
  21     import PyQt4,sip
  22     from PyQt4 import QtGui,QtCore
  23     import dbus.mainloop.qt
  24     import dbus
  25 except ImportError as e:
  26     sys.stderr.write('There was an error importing needed libraries\n'
  27                      'Make sure you have qt4 and dbus-python installed\n'
  28                      'The error that occured was:\n'
  29                      '\t%s\n' % (str(e)))
  30     sys.exit(-1)
  31
  32 from functools import partial
  33
  34 import signal
  35 signal.signal(signal.SIGINT, signal.SIG_DFL)
  36 SYNC_TIMEOUT = 4*1000
  37
  38 CORE_PATH = "/org/pulseaudio/core1"
  39 CORE_IFACE = "org.PulseAudio.Core1"
  40 def connect():
  41     try:
  42         if 'PULSE_DBUS_SERVER' in os.environ:
  43             address = os.environ['PULSE_DBUS_SERVER']
  44         else:
  45             bus = dbus.SessionBus() # Should be UserBus, but D-Bus doesn't implement that yet.
  46             server_lookup = bus.get_object('org.PulseAudio1', '/org/pulseaudio/server_lookup1')
  47             address = server_lookup.Get('org.PulseAudio.ServerLookup1', 'Address', dbus_interface='org.freedesktop.DBus.Properties')
  48         return dbus.connection.Connection(address)
  49     except Exception as e:
  50         sys.stderr.write('There was an error connecting to pulseaudio, '
  51                          'please make sure you have the pulseaudio dbus '
  52                          'and equalizer modules loaded, exiting...\n')
  53         sys.exit(-1)
  54
  55
  56 #TODO: signals: sink Filter changed, sink reconfigured (window size) (sink iface)
  57 #TODO: manager signals: new sink, removed sink, new profile, removed profile
  58 #TODO: add support for changing of window_size 1000-fft_size (adv option)
  59 #TODO: reconnect support loop 1 second trying to reconnect
  60 #TODO: just resample the filters for profiles when loading to different sizes
  61 #TODO: add preamp
  62 prop_iface='org.freedesktop.DBus.Properties'
  63 eq_iface='org.PulseAudio.Ext.Equalizing1.Equalizer'
  64 device_iface='org.PulseAudio.Core1.Device'
  65 class QPaeq(QtGui.QWidget):
  66     manager_path='/org/pulseaudio/equalizing1'
  67     manager_iface='org.PulseAudio.Ext.Equalizing1.Manager'
  68     core_iface='org.PulseAudio.Core1'
  69     core_path='/org/pulseaudio/core1'
  70     def __init__(self):
  71         QtGui.QWidget.__init__(self)
  72         self.setWindowTitle('qpaeq')
  73         self.slider_widget=None
  74         self.sink_name=None
  75         self.filter_state=None
  76
  77         self.create_layout()
  78
  79         self.set_connection()
  80         self.connect_to_sink(self.sinks[0])
  81         self.set_callbacks()
  82         self.setMinimumSize(self.sizeHint())
  83
  84     def create_layout(self):
  85         self.main_layout=QtGui.QVBoxLayout()
  86         self.setLayout(self.main_layout)
  87         toprow_layout=QtGui.QHBoxLayout()
  88         sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Fixed)
  89         sizePolicy.setHorizontalStretch(0)
  90         sizePolicy.setVerticalStretch(0)
  91         #sizePolicy.setHeightForWidth(self.profile_box.sizePolicy().hasHeightForWidth())
  92
  93         toprow_layout.addWidget(QtGui.QLabel('Sink'))
  94         self.sink_box = QtGui.QComboBox()
  95         self.sink_box.setSizePolicy(sizePolicy)
  96         self.sink_box.setDuplicatesEnabled(False)
  97         self.sink_box.setInsertPolicy(QtGui.QComboBox.InsertAlphabetically)
  98         #self.sink_box.setSizeAdjustPolicy(QtGui.QComboBox.AdjustToContents)
  99         toprow_layout.addWidget(self.sink_box)
 100
 101         toprow_layout.addWidget(QtGui.QLabel('Channel'))
 102         self.channel_box = QtGui.QComboBox()
 103         self.channel_box.setSizePolicy(sizePolicy)
 104         toprow_layout.addWidget(self.channel_box)
 105
 106         toprow_layout.addWidget(QtGui.QLabel('Preset'))
 107         self.profile_box = QtGui.QComboBox()
 108         self.profile_box.setSizePolicy(sizePolicy)
 109         self.profile_box.setInsertPolicy(QtGui.QComboBox.InsertAlphabetically)
 110         #self.profile_box.setSizeAdjustPolicy(QtGui.QComboBox.AdjustToContents)
 111         toprow_layout.addWidget(self.profile_box)
 112
 113         large_icon_size=self.style().pixelMetric(QtGui.QStyle.PM_LargeIconSize)
 114         large_icon_size=QtCore.QSize(large_icon_size,large_icon_size)
 115         save_profile=QtGui.QToolButton()
 116         save_profile.setIcon(self.style().standardIcon(QtGui.QStyle.SP_DriveFDIcon))
 117         save_profile.setIconSize(large_icon_size)
 118         save_profile.setToolButtonStyle(QtCore.Qt.ToolButtonIconOnly)
 119         save_profile.clicked.connect(self.save_profile)
 120         remove_profile=QtGui.QToolButton()
 121         remove_profile.setIcon(self.style().standardIcon(QtGui.QStyle.SP_TrashIcon))
 122         remove_profile.setIconSize(large_icon_size)
 123         remove_profile.setToolButtonStyle(QtCore.Qt.ToolButtonIconOnly)
 124         remove_profile.clicked.connect(self.remove_profile)
 125         toprow_layout.addWidget(save_profile)
 126         toprow_layout.addWidget(remove_profile)
 127
 128         reset_button = QtGui.QPushButton('Reset')
 129         reset_button.clicked.connect(self.reset)
 130         toprow_layout.addStretch()
 131         toprow_layout.addWidget(reset_button)
 132         self.layout().addLayout(toprow_layout)
 133
 134         self.profile_box.activated.connect(self.load_profile)
 135         self.channel_box.activated.connect(self.select_channel)
 136     def connect_to_sink(self,name):
 137         #TODO: clear slots for profile buttons
 138
 139         #flush any pending saves for other sinks
 140         if self.filter_state is not None:
 141             self.filter_state.flush_state()
 142         sink=self.connection.get_object(object_path=name)
 143         self.sink_props=dbus.Interface(sink,dbus_interface=prop_iface)
 144         self.sink=dbus.Interface(sink,dbus_interface=eq_iface)
 145         self.filter_state=FilterState(sink)
 146         #sample_rate,filter_rate,channels,channel)
 147
 148         self.channel_box.clear()
 149         self.channel_box.addItem('All',self.filter_state.channels)
 150         for i in range(self.filter_state.channels):
 151             self.channel_box.addItem('%d' %(i+1,),i)
 152         self.setMinimumSize(self.sizeHint())
 153
 154         self.set_slider_widget(SliderArray(self.filter_state))
 155
 156         self.sink_name=name
 157         #set the signal listener for this sink
 158         core=self._get_core()
 159         #temporary hack until signal filtering works properly
 160         core.ListenForSignal('',[dbus.ObjectPath(self.sink_name),dbus.ObjectPath(self.manager_path)])
 161         #for x in ['FilterChanged']:
 162         #    core.ListenForSignal("%s.%s" %(self.eq_iface,x),[dbus.ObjectPath(self.sink_name)])
 163         #core.ListenForSignal(self.eq_iface,[dbus.ObjectPath(self.sink_name)])
 164         self.sink.connect_to_signal('FilterChanged',self.read_filter)
 165
 166     def set_slider_widget(self,widget):
 167         layout=self.layout()
 168         if self.slider_widget is not None:
 169             i=layout.indexOf(self.slider_widget)
 170             layout.removeWidget(self.slider_widget)
 171             self.slider_widget.deleteLater()
 172             layout.insertWidget(i,self.slider_widget)
 173         else:
 174             layout.addWidget(widget)
 175         self.slider_widget=widget
 176         self.read_filter()
 177     def _get_core(self):
 178         core_obj=self.connection.get_object(object_path=self.core_path)
 179         core=dbus.Interface(core_obj,dbus_interface=self.core_iface)
 180         return core
 181     def sink_added(self,sink):
 182         #TODO: preserve selected sink
 183         self.update_sinks()
 184     def sink_removed(self,sink):
 185         #TODO: preserve selected sink, try connecting to backup otherwise
 186         if sink==self.sink_name:
 187             #connect to new sink?
 188             pass
 189         self.update_sinks()
 190     def save_profile(self):
 191         #popup dialog box for name
 192         current=self.profile_box.currentIndex()
 193         profile,ok=QtGui.QInputDialog.getItem(self,'Preset Name','Preset',self.profiles,current)
 194         if not ok or profile=='':
 195             return
 196         if profile in self.profiles:
 197             mbox=QtGui.QMessageBox(self)
 198             mbox.setText('%s preset already exists'%(profile,))
 199             mbox.setInformativeText('Do you want to save over it?')
 200             mbox.setStandardButtons(mbox.Save|mbox.Discard|mbox.Cancel)
 201             mbox.setDefaultButton(mbox.Save)
 202             ret=mbox.exec_()
 203             if ret!=mbox.Save:
 204                 return
 205         self.sink.SaveProfile(self.filter_state.channel,dbus.String(profile))
 206         if self.filter_state.channel==self.filter_state.channels:
 207             for x in range(1,self.filter_state.channels):
 208                 self.sink.LoadProfile(x,dbus.String(profile))
 209     def remove_profile(self):
 210         #find active profile name, remove it
 211         profile=self.profile_box.currentText()
 212         manager=dbus.Interface(self.manager_obj,dbus_interface=self.manager_iface)
 213         manager.RemoveProfile(dbus.String(profile))
 214     def load_profile(self,x):
 215         profile=self.profile_box.itemText(x)
 216         self.filter_state.load_profile(profile)
 217     def select_channel(self,x):
 218         self.filter_state.channel = self.channel_box.itemData(x).toPyObject()
 219         self._set_profile_name()
 220         self.filter_state.readback()
 221
 222     #TODO: add back in preamp!
 223     #print(frequencies)
 224     #main_layout.addLayout(self.create_slider(partial(self.update_coefficient,0),
 225     #    'Preamp')[0]
 226     #)
 227     def set_connection(self):
 228         self.connection=connect()
 229         self.manager_obj=self.connection.get_object(object_path=self.manager_path)
 230         manager_props=dbus.Interface(self.manager_obj,dbus_interface=prop_iface)
 231         self.sinks=manager_props.Get(self.manager_iface,'EqualizedSinks')
 232     def set_callbacks(self):
 233         manager=dbus.Interface(self.manager_obj,dbus_interface=self.manager_iface)
 234         manager.connect_to_signal('ProfilesChanged',self.update_profiles)
 235         manager.connect_to_signal('SinkAdded',self.sink_added)
 236         manager.connect_to_signal('SinkRemoved',self.sink_removed)
 237         #self._get_core().ListenForSignal(self.manager_iface,[])
 238         #self._get_core().ListenForSignal(self.manager_iface,[dbus.ObjectPath(self.manager_path)])
 239         #core=self._get_core()
 240         #for x in ['ProfilesChanged','SinkAdded','SinkRemoved']:
 241         #    core.ListenForSignal("%s.%s" %(self.manager_iface,x),[dbus.ObjectPath(self.manager_path)])
 242         self.update_profiles()
 243         self.update_sinks()
 244     def update_profiles(self):
 245         #print('update profiles called!')
 246         manager_props=dbus.Interface(self.manager_obj,dbus_interface=prop_iface)
 247         self.profiles=manager_props.Get(self.manager_iface,'Profiles')
 248         self.profile_box.blockSignals(True)
 249         self.profile_box.clear()
 250         self.profile_box.addItems(self.profiles)
 251         self.profile_box.blockSignals(False)
 252         self._set_profile_name()
 253     def update_sinks(self):
 254         self.sink_box.blockSignals(True)
 255         self.sink_box.clear()
 256         for x in self.sinks:
 257             sink=self.connection.get_object(object_path=x)
 258             sink_props=dbus.Interface(sink,dbus_interface=prop_iface)
 259             simple_name=sink_props.Get(device_iface,'Name')
 260             self.sink_box.addItem(simple_name,x)
 261         self.sink_box.blockSignals(False)
 262         self.sink_box.setMinimumSize(self.sink_box.sizeHint())
 263     def read_filter(self):
 264         #print(self.filter_frequencies)
 265         self.filter_state.readback()
 266     def reset(self):
 267         coefs=dbus.Array([1/math.sqrt(2.0)]*(self.filter_state.filter_rate//2+1))
 268         preamp=1.0
 269         self.filter_state.set_filter(preamp,coefs)
 270     def _set_profile_name(self):
 271         self.profile_box.blockSignals(True)
 272         profile_name=self.sink.BaseProfile(self.filter_state.channel)
 273         if profile_name is not None:
 274             i=self.profile_box.findText(profile_name)
 275             if i>=0:
 276                 self.profile_box.setCurrentIndex(i)
 277         self.profile_box.blockSignals(False)
 278
 279
 280 class SliderArray(QtGui.QWidget):
 281     def __init__(self,filter_state,parent=None):
 282         super(SliderArray,self).__init__(parent)
 283         #self.setStyleSheet('padding: 0px; border-width: 0px; margin: 0px;')
 284         #self.setStyleSheet('font-size: 7pt; font-family: monospace;'+outline%('blue'))
 285         self.filter_state=filter_state
 286         self.setLayout(QtGui.QHBoxLayout())
 287         self.sub_array=None
 288         self.set_sub_array(SliderArraySub(self.filter_state))
 289         self.inhibit_resize=0
 290     def set_sub_array(self,widget):
 291         if self.sub_array is not None:
 292             self.layout().removeWidget(self.sub_array)
 293             self.sub_array.disconnect_signals()
 294             self.sub_array.deleteLater()
 295         self.sub_array=widget
 296         self.layout().addWidget(self.sub_array)
 297         self.sub_array.connect_signals()
 298         self.filter_state.readback()
 299     def resizeEvent(self,event):
 300         super(SliderArray,self).resizeEvent(event)
 301         if self.inhibit_resize==0:
 302             self.inhibit_resize+=1
 303             #self.add_sliders_to_fit()
 304             t=QtCore.QTimer(self)
 305             t.setSingleShot(True)
 306             t.setInterval(0)
 307             t.timeout.connect(partial(self.add_sliders_to_fit,event))
 308             t.start()
 309     def add_sliders_to_fit(self,event):
 310         if event.oldSize().width()>0 and event.size().width()>0:
 311             i=len(self.filter_state.frequencies)*int(round(float(event.size().width())/event.oldSize().width()))
 312         else:
 313             i=len(self.filter_state.frequencies)
 314
 315         t_w=self.size().width()
 316         def evaluate(filter_state, target, variable):
 317             base_freqs=self.filter_state.freq_proper(self.filter_state.DEFAULT_FREQUENCIES)
 318             filter_state._set_frequency_values(subdivide(base_freqs,variable))
 319             new_widget=SliderArraySub(filter_state)
 320             w=new_widget.sizeHint().width()
 321             return w-target
 322         def searcher(initial,evaluator):
 323             i=initial
 324             def d(e): return 1 if e>=0 else -1
 325             error=evaluator(i)
 326             old_direction=d(error)
 327             i-=old_direction
 328             while True:
 329                 error=evaluator(i)
 330                 direction=d(error)
 331                 if direction!=old_direction:
 332                     k=i-1
 333                     #while direction<0 and error!=0:
 334                     #    k-=1
 335                     #    error=evaluator(i)
 336                     #    direction=d(error)
 337                     return k, evaluator(k)
 338                 i-=direction
 339                 old_direction=direction
 340         searcher(i,partial(evaluate,self.filter_state,t_w))
 341         self.set_sub_array(SliderArraySub(self.filter_state))
 342         self.inhibit_resize-=1
 343
 344 class SliderArraySub(QtGui.QWidget):
 345     def __init__(self,filter_state,parent=None):
 346         super(SliderArraySub,self).__init__(parent)
 347         self.filter_state=filter_state
 348         self.setLayout(QtGui.QGridLayout())
 349         self.slider=[None]*len(self.filter_state.frequencies)
 350         self.label=[None]*len(self.slider)
 351         #self.setStyleSheet('padding: 0px; border-width: 0px; margin: 0px;')
 352         #self.setStyleSheet('font-size: 7pt; font-family: monospace;'+outline%('blue'))
 353         qt=QtCore.Qt
 354         #self.layout().setHorizontalSpacing(1)
 355         def add_slider(slider,label, c):
 356             self.layout().addWidget(slider,0,c,qt.AlignHCenter)
 357             self.layout().addWidget(label,1,c,qt.AlignHCenter)
 358             self.layout().setColumnMinimumWidth(c,max(label.sizeHint().width(),slider.sizeHint().width()))
 359         def create_slider(slider_label):
 360             slider=QtGui.QSlider(QtCore.Qt.Vertical,self)
 361             label=SliderLabel(slider_label,filter_state,self)
 362             slider.setRange(-1000,2000)
 363             slider.setSingleStep(1)
 364             return (slider,label)
 365         self.preamp_slider,self.preamp_label=create_slider('Preamp')
 366         add_slider(self.preamp_slider,self.preamp_label,0)
 367         for i,hz in enumerate(self.filter_state.frequencies):
 368             slider,label=create_slider(self.hz2label(hz))
 369             self.slider[i]=slider
 370             #slider.setStyleSheet('font-size: 7pt; font-family: monospace;'+outline%('red',))
 371             self.label[i]=label
 372             c=i+1
 373             add_slider(slider,label,i+1)
 374     def hz2label(self, hz):
 375         if hz==0:
 376             label_text='DC'
 377         elif hz==self.filter_state.sample_rate//2:
 378             label_text='Coda'
 379         else:
 380             label_text=hz2str(hz)
 381         return label_text
 382
 383     def connect_signals(self):
 384         def connect(writer,reader,slider,label):
 385             slider.valueChanged.connect(writer)
 386             self.filter_state.readFilter.connect(reader)
 387             label_cb=partial(slider.setValue,0)
 388             label.clicked.connect(label_cb)
 389             return label_cb
 390
 391         self.preamp_writer_cb=self.write_preamp
 392         self.preamp_reader_cb=self.sync_preamp
 393         self.preamp_label_cb=connect(self.preamp_writer_cb,
 394                 self.preamp_reader_cb,
 395                 self.preamp_slider,
 396                 self.preamp_label)
 397         self.writer_callbacks=[None]*len(self.slider)
 398         self.reader_callbacks=[None]*len(self.slider)
 399         self.label_callbacks=[None]*len(self.label)
 400         for i in range(len(self.slider)):
 401             self.writer_callbacks[i]=partial(self.write_coefficient,i)
 402             self.reader_callbacks[i]=partial(self.sync_coefficient,i)
 403             self.label_callbacks[i]=connect(self.writer_callbacks[i],
 404                     self.reader_callbacks[i],
 405                     self.slider[i],
 406                     self.label[i])
 407     def disconnect_signals(self):
 408         def disconnect(writer,reader,label_cb,slider,label):
 409             slider.valueChanged.disconnect(writer)
 410             self.filter_state.readFilter.disconnect(reader)
 411             label.clicked.disconnect(label_cb)
 412         disconnect(self.preamp_writer_cb, self.preamp_reader_cb,
 413                 self.preamp_label_cb, self.preamp_slider, self.preamp_label)
 414         for i in range(len(self.slider)):
 415             disconnect(self.writer_callbacks[i],
 416                     self.reader_callbacks[i],
 417                     self.label_callbacks[i],
 418                     self.slider[i],
 419                     self.label[i])
 420
 421     def write_preamp(self, v):
 422         self.filter_state.preamp=self.slider2coef(v)
 423         self.filter_state.seed()
 424     def sync_preamp(self):
 425         self.preamp_slider.blockSignals(True)
 426         self.preamp_slider.setValue(self.coef2slider(self.filter_state.preamp))
 427         self.preamp_slider.blockSignals(False)
 428
 429
 430     def write_coefficient(self,i,v):
 431         self.filter_state.coefficients[i]=self.slider2coef(v)/math.sqrt(2.0)
 432         self.filter_state.seed()
 433     def sync_coefficient(self,i):
 434         slider=self.slider[i]
 435         slider.blockSignals(True)
 436         slider.setValue(self.coef2slider(math.sqrt(2.0)*self.filter_state.coefficients[i]))
 437         slider.blockSignals(False)
 438     @staticmethod
 439     def slider2coef(x):
 440         return (1.0+(x/1000.0))
 441     @staticmethod
 442     def coef2slider(x):
 443         return int((x-1.0)*1000)
 444 outline='border-width: 1px; border-style: solid; border-color: %s;'
 445
 446 class SliderLabel(QtGui.QLabel):
 447     clicked=QtCore.pyqtSignal()
 448     def __init__(self,label_text,filter_state,parent=None):
 449         super(SliderLabel,self).__init__(parent)
 450         self.setStyleSheet('font-size: 7pt; font-family: monospace;')
 451         self.setText(label_text)
 452         self.setMinimumSize(self.sizeHint())
 453     def mouseDoubleClickEvent(self, event):
 454         self.clicked.emit()
 455         super(SliderLabel,self).mouseDoubleClickEvent(event)
 456
 457 #until there are server side state savings, do it in the client but try and avoid
 458 #simulaneous broadcasting situations
 459 class FilterState(QtCore.QObject):
 460     #DEFAULT_FREQUENCIES=map(float,[25,50,75,100,150,200,300,400,500,800,1e3,1.5e3,3e3,5e3,7e3,10e3,15e3,20e3])
 461     DEFAULT_FREQUENCIES=[31.75,63.5,125,250,500,1e3,2e3,4e3,8e3,16e3]
 462     readFilter=QtCore.pyqtSignal()
 463     def __init__(self,sink):
 464         super(FilterState,self).__init__()
 465         self.sink_props=dbus.Interface(sink,dbus_interface=prop_iface)
 466         self.sink=dbus.Interface(sink,dbus_interface=eq_iface)
 467         self.sample_rate=self.get_eq_attr('SampleRate')
 468         self.filter_rate=self.get_eq_attr('FilterSampleRate')
 469         self.channels=self.get_eq_attr('NChannels')
 470         self.channel=self.channels
 471         self.set_frequency_values(self.DEFAULT_FREQUENCIES)
 472         self.sync_timer=QtCore.QTimer()
 473         self.sync_timer.setSingleShot(True)
 474         self.sync_timer.timeout.connect(self.save_state)
 475
 476     def get_eq_attr(self,attr):
 477         return self.sink_props.Get(eq_iface,attr)
 478     def freq_proper(self,xs):
 479         return [0]+xs+[self.sample_rate//2]
 480     def _set_frequency_values(self,freqs):
 481         self.frequencies=freqs
 482         #print('base',self.frequencies)
 483         self.filter_frequencies=[int(round(x)) for x in self.translate_rates(self.filter_rate,self.sample_rate,
 484                     self.frequencies)]
 485         self.coefficients=[0.0]*len(self.frequencies)
 486         self.preamp=1.0
 487     def set_frequency_values(self,freqs):
 488         self._set_frequency_values(self.freq_proper(freqs))
 489     @staticmethod
 490     def translate_rates(dst,src,rates):
 491         return list([x*dst/src for x in rates])
 492     def seed(self):
 493         self.sink.SeedFilter(self.channel,self.filter_frequencies,self.coefficients,self.preamp)
 494         self.sync_timer.start(SYNC_TIMEOUT)
 495     def readback(self):
 496         coefs,preamp=self.sink.FilterAtPoints(self.channel,self.filter_frequencies)
 497         self.coefficients=coefs
 498         self.preamp=preamp
 499         self.readFilter.emit()
 500     def set_filter(self,preamp,coefs):
 501         self.sink.SetFilter(self.channel,dbus.Array(coefs),self.preamp)
 502         self.sync_timer.start(SYNC_TIMEOUT)
 503     def save_state(self):
 504         print('saving state')
 505         self.sink.SaveState()
 506     def load_profile(self,profile):
 507         self.sink.LoadProfile(self.channel,dbus.String(profile))
 508         self.sync_timer.start(SYNC_TIMEOUT)
 509     def flush_state(self):
 510         if self.sync_timer.isActive():
 511             self.sync_timer.stop()
 512             self.save_state()
 513
 514
 515 def safe_log(k,b):
 516     i=0
 517     while k//b!=0:
 518         i+=1
 519         k=k//b
 520     return i
 521 def hz2str(hz):
 522     p=safe_log(hz,10.0)
 523     if p<3:
 524         return '%dHz' %(hz,)
 525     elif hz%1000==0:
 526         return '%dKHz' %(hz/(10.0**3),)
 527     else:
 528         return '%.1fKHz' %(hz/(10.0**3),)
 529
 530 def subdivide(xs, t_points):
 531     while len(xs)<t_points:
 532         m=[0]*(2*len(xs)-1)
 533         m[0:len(m):2]=xs
 534         for i in range(1,len(m),2):
 535             m[i]=(m[i-1]+m[i+1])//2
 536         xs=m
 537     p_drop=len(xs)-t_points
 538     p_drop_left=p_drop//2
 539     p_drop_right=p_drop-p_drop_left
 540     #print('xs',xs)
 541     #print('dropping %d, %d left, %d right' %(p_drop,p_drop_left,p_drop_right))
 542     c=len(xs)//2
 543     left=xs[0:p_drop_left*2:2]+xs[p_drop_left*2:c]
 544     right=list(reversed(xs[c:]))
 545     right=right[0:p_drop_right*2:2]+right[p_drop_right*2:]
 546     right=list(reversed(right))
 547     return left+right
 548
 549 def main():
 550     dbus.mainloop.qt.DBusQtMainLoop(set_as_default=True)
 551     app=QtGui.QApplication(sys.argv)
 552     qpaeq_main=QPaeq()
 553     qpaeq_main.show()
 554     sys.exit(app.exec_())
 555
 556 if __name__=='__main__':
 557     main()