Changeset 2670

Show
Ignore:
Timestamp:
01/09/17 04:50:19 (4 years ago)
Author:
jwoithe
Message:

Add the "-b" / "--bypassdbus" command line option to ffado-mixer. If given,
no communication with ffado-dbus-server will be attempted. Instead, an
instance of each supported mixer module will be created with stubs providing
placeholder values in place of values obtained from hardware. This permits
rudimentary debugging of mixer modules for interfaces which the developer
does not have on hand.

This commit amounts to a minor rework of a patch originally submitted by
Xavier Forestier as part of a large series which is being slowly merged:

https://sourceforge.net/p/ffado/mailman/message/35457569/.

The most significant difference is that the bypassdbus functionality in
Xavier's patch was a compile option whereas the commit implements it as a
runtime option. It is felt that this will make things easier for developers
in the long run: mixer modules can be tested without having to reconfigure
ffado from source. Minor bug fixes were applied to the patch as it was
reworked.

Thanks to Xavier Forestier for the original patch.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/support/mixer-qt4/ffado/config.py.in

    r2471 r2670  
    2020DEBUG = $DEBUG 
    2121 
     22# If set true it will open all mixers 
     23bypassdbus = False 
     24 
    2225UIDIR = PYTHONDIR 
    2326import os.path 
  • trunk/libffado/support/mixer-qt4/ffado/dbus_util.py

    r2428 r2670  
    2121# along with this program.  If not, see <http://www.gnu.org/licenses/>. 
    2222# 
     23import ffado.config 
     24from ffado.configuration import * 
    2325 
    2426import dbus 
     
    3335        self.basepath=basepath 
    3436        self.servername=servername 
    35         self.bus=dbus.SessionBus() 
     37        if ffado.config.bypassdbus: 
     38            self.devices = DeviceList(ffado.config.SYSTEM_CONFIG_FILE) 
     39            self.devices.updateFromFile(ffado.config.USER_CONFIG_FILE) 
     40        else: 
     41            self.bus=dbus.SessionBus() 
    3642 
    3743    def setContignuous(self, subpath, v, idx=None): 
    38         try: 
    39             path = self.basepath + subpath 
     44        path = self.basepath + subpath 
     45        if ffado.config.bypassdbus: 
     46            log.info("bypassdbus set, would set Continuous %s on server %s" % (path, self.servername)) 
     47            return 
     48        try: 
    4049            dev = self.bus.get_object(self.servername, path) 
    4150            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Continuous') 
     
    4857 
    4958    def getContignuous(self, subpath, idx=None): 
    50         try: 
    51             path = self.basepath + subpath 
     59        path = self.basepath + subpath 
     60        if ffado.config.bypassdbus: 
     61            log.info("bypassdbus set, would get Continuous %s on server %s" % (path, self.servername)) 
     62            return 0 
     63        try: 
    5264            dev = self.bus.get_object(self.servername, path) 
    5365            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Continuous') 
     
    6173 
    6274    def setDiscrete(self, subpath, v, idx=None): 
    63         try: 
    64             path = self.basepath + subpath 
     75        path = self.basepath + subpath 
     76        if ffado.config.bypassdbus: 
     77            log.info("bypassdbus set, would set Discrete %s on server %s" % (path, self.servername)) 
     78            return 
     79        try: 
    6580            dev = self.bus.get_object(self.servername, path) 
    6681            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Discrete') 
     
    7388 
    7489    def getDiscrete(self, subpath, idx=None): 
    75         try: 
    76             path = self.basepath + subpath 
     90        path = self.basepath + subpath 
     91        if ffado.config.bypassdbus: 
     92             log.info("bypassdbus set, would get Discrete %s on server %s" % (path, self.servername)) 
     93             return 0 
     94        try: 
    7795            dev = self.bus.get_object(self.servername, path) 
    7896            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Discrete') 
     
    86104 
    87105    def setText(self, subpath, v): 
    88         try: 
    89             path = self.basepath + subpath 
     106        path = self.basepath + subpath 
     107        if ffado.config.bypassdbus: 
     108            log.info("DEBUG_BYPASSDBUS set, would set Text %s on server %s" % (path, self.servername)) 
     109            return 
     110        try: 
    90111            dev = self.bus.get_object(self.servername, path) 
    91112            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Text') 
     
    95116 
    96117    def getText(self, subpath): 
    97         try: 
    98             path = self.basepath + subpath 
     118        path = self.basepath + subpath 
     119        if ffado.config.bypassdbus: 
     120            log.info("bypassdbus set, would get get Text %s on server %s" % (path, self.servername)) 
     121            return "" 
     122        try: 
    99123            dev = self.bus.get_object(self.servername, path) 
    100124            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Text') 
     
    105129 
    106130    def setMatrixMixerValue(self, subpath, row, col, v): 
    107         try: 
    108             path = self.basepath + subpath 
     131        path = self.basepath + subpath 
     132        if ffado.config.bypassdbus: 
     133            log.info("bypassdbus set, would set MatrixMixer %s on server %s" % (path, self.servername)) 
     134            return 
     135        try: 
    109136            dev = self.bus.get_object(self.servername, path) 
    110137            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.MatrixMixer') 
     
    114141 
    115142    def getMatrixMixerValue(self, subpath, row, col): 
    116         try: 
    117             path = self.basepath + subpath 
     143        path = self.basepath + subpath 
     144        if ffado.config.bypassdbus: 
     145            log.info("bypassdbus set, would get MatrixMixer %s on server %s" % (path, self.servername)) 
     146            return 0 
     147        try: 
    118148            dev = self.bus.get_object(self.servername, path) 
    119149            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.MatrixMixer') 
     
    124154 
    125155    def enumSelect(self, subpath, v): 
    126         try: 
    127             path = self.basepath + subpath 
     156        path = self.basepath + subpath 
     157        if ffado.config.bypassdbus: 
     158            log.info("bypassdbus set, would select %s on server %s" % (path, self.servername)) 
     159            return 
     160        try: 
    128161            dev = self.bus.get_object(self.servername, path) 
    129162            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Enum') 
     
    133166 
    134167    def enumSelected(self, subpath): 
    135         try: 
    136             path = self.basepath + subpath 
     168        path = self.basepath + subpath 
     169        if ffado.config.bypassdbus: 
     170            log.info("bypassdbus set, would get selected enum %s on server %s" % (path, self.servername)) 
     171            return 0 
     172        try: 
    137173            dev = self.bus.get_object(self.servername, path) 
    138174            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Enum') 
     
    143179 
    144180    def enumGetLabel(self, subpath, v): 
    145         try: 
    146             path = self.basepath + subpath 
     181        path = self.basepath + subpath 
     182        if ffado.config.bypassdbus: 
     183            log.info("bypassdbus set, would get enum label %s on server %s" % (path, self.servername)) 
     184            return 0 
     185        try: 
    147186            dev = self.bus.get_object(self.servername, path) 
    148187            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Enum') 
     
    153192 
    154193    def enumCount(self, subpath): 
    155         try: 
    156             path = self.basepath + subpath 
     194        path = self.basepath + subpath 
     195        if ffado.config.bypassdbus: 
     196            log.info("bypassdbus set, would get enum count %s on server %s" % (path, self.servername)) 
     197            return 0 
     198        try: 
    157199            dev = self.bus.get_object(self.servername, path) 
    158200            dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Enum') 
     
    167209        self.basepath=basepath + '/DeviceManager' 
    168210        self.servername=servername 
    169         self.bus=dbus.SessionBus() 
    170         self.dev = self.bus.get_object(self.servername, self.basepath) 
    171         self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Container') 
     211        if ffado.config.bypassdbus: 
     212            self.devices = DeviceList(ffado.config.SYSTEM_CONFIG_FILE) 
     213            self.devices.updateFromFile(ffado.config.USER_CONFIG_FILE) 
     214        else: 
     215            self.bus=dbus.SessionBus() 
     216            self.dev = self.bus.get_object(self.servername, self.basepath) 
     217            self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Container') 
    172218 
    173219        self.updateSignalHandlers = [] 
     
    179225        self.destroyedSignalHandlers = [] 
    180226        self.destroyedSignalHandlerArgs = {} 
     227 
     228        if ffado.config.bypassdbus: 
     229            return 
    181230 
    182231        # signal reception does not work yet since we need a mainloop for that 
     
    269318 
    270319    def getNbDevices(self): 
     320        if ffado.config.bypassdbus: 
     321            return len(self.devices.devices) 
    271322        return self.iface.getNbElements() 
    272323    def getDeviceName(self, idx): 
     324        if ffado.config.bypassdbus: 
     325            return str(idx) 
    273326        return self.iface.getElementName(idx) 
    274327 
     
    277330        self.basepath=devicepath + '/ConfigRom' 
    278331        self.servername=servername 
    279         self.bus=dbus.SessionBus() 
    280         self.dev = self.bus.get_object(self.servername, self.basepath) 
    281         self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.ConfigRomX') 
     332        if ffado.config.bypassdbus: 
     333            self.devices = DeviceList(ffado.config.SYSTEM_CONFIG_FILE) 
     334            self.devices.updateFromFile(ffado.config.USER_CONFIG_FILE) 
     335            self.idx = int(devicepath) 
     336        else: 
     337            self.bus=dbus.SessionBus() 
     338            self.dev = self.bus.get_object(self.servername, self.basepath) 
     339            self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.ConfigRomX') 
    282340    def getGUID(self): 
     341        if ffado.config.bypassdbus: 
     342            return str(self.idx) 
    283343        return self.iface.getGUID() 
    284344    def getVendorName(self): 
     345        if ffado.config.bypassdbus: 
     346            return self.devices.devices[self.idx]['vendorname'] 
    285347        return self.iface.getVendorName() 
    286348    def getModelName(self): 
     349        if ffado.config.bypassdbus: 
     350            return self.devices.devices[self.idx]['modelname'] 
    287351        return self.iface.getModelName() 
    288352    def getVendorId(self): 
     353        if ffado.config.bypassdbus: 
     354            return int(self.devices.devices[self.idx]['vendorid'], 16) 
    289355        return self.iface.getVendorId() 
    290356    def getModelId(self): 
     357        if ffado.config.bypassdbus: 
     358            return int(self.devices.devices[self.idx]['modelid'], 16) 
    291359        return self.iface.getModelId() 
    292360    def getUnitVersion(self): 
     361        if ffado.config.bypassdbus: 
     362            return 0 
    293363        return self.iface.getUnitVersion() 
    294364 
     
    297367        self.basepath=devicepath + '/Generic/ClockSelect' 
    298368        self.servername=servername 
    299         self.bus=dbus.SessionBus() 
    300         self.dev = self.bus.get_object(self.servername, self.basepath) 
    301         self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.AttributeEnum') 
    302         self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element') 
     369        if ffado.config.bypassdbus: 
     370            self.devices = DeviceList(ffado.config.SYSTEM_CONFIG_FILE) 
     371            self.devices.updateFromFile(ffado.config.USER_CONFIG_FILE) 
     372            self.idx = devicepath 
     373        else: 
     374            self.bus=dbus.SessionBus() 
     375            self.dev = self.bus.get_object(self.servername, self.basepath) 
     376            self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.AttributeEnum') 
     377            self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element') 
    303378    def count(self): 
     379        if ffado.config.bypassdbus: 
     380            return 1 
    304381        return self.iface.count() 
    305382    def select(self, idx): 
     383        if ffado.config.bypassdbus: 
     384            return 1 
    306385        return self.iface.select(idx) 
    307386    def selected(self): 
     387        if ffado.config.bypassdbus: 
     388            return True 
    308389        return self.iface.selected() 
    309390    def getEnumLabel(self, idx): 
     391        if ffado.config.bypassdbus: 
     392            return 'enumlabel ' + str(idx) 
    310393        return self.iface.getEnumLabel(idx) 
    311394    def attributeCount(self): 
     395        if ffado.config.bypassdbus: 
     396            return 1 
    312397        return self.iface.attributeCount() 
    313398    def getAttributeValue(self, idx): 
     399        if ffado.config.bypassdbus: 
     400            return 1 
    314401        return self.iface.getAttributeValue(idx) 
    315402    def getAttributeName(self, idx): 
     403        if ffado.config.bypassdbus: 
     404            return 'attrib ' + str(idx) 
    316405        return self.iface.getAttributeName(idx) 
    317406    def canChangeValue(self): 
     407        if ffado.config.bypassdbus: 
     408            return 1 
    318409        return self.iface_element.canChangeValue() 
    319410 
     
    322413        self.basepath = basepath 
    323414        self.servername = servername 
    324         self.bus = dbus.SessionBus() 
    325         self.dev = self.bus.get_object(self.servername, self.basepath) 
    326         self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Enum') 
    327         self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element') 
     415        if ffado.config.bypassdbus: 
     416            self.devices = DeviceList(ffado.config.SYSTEM_CONFIG_FILE) 
     417            self.devices.updateFromFile(ffado.config.USER_CONFIG_FILE) 
     418        else: 
     419            self.bus = dbus.SessionBus() 
     420            self.dev = self.bus.get_object(self.servername, self.basepath) 
     421            self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Enum') 
     422            self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element') 
    328423    def count(self): 
     424        if ffado.config.bypassdbus: 
     425            return 1 
    329426        return self.iface.count() 
    330427    def select(self, idx): 
     428        if ffado.config.bypassdbus: 
     429            return 1 
    331430        return self.iface.select(idx) 
    332431    def selected(self): 
     432        if ffado.config.bypassdbus: 
     433            return True 
    333434        return self.iface.selected() 
    334435    def getEnumLabel(self, idx): 
     436        if ffado.config.bypassdbus: 
     437            # Can't include text here since some code uses int() to extract 
     438            # a value from the enum label 
     439            return '0' 
    335440        return self.iface.getEnumLabel(idx) 
    336441    def canChangeValue(self): 
     442        if ffado.config.bypassdbus: 
     443            return True 
    337444        return self.iface_element.canChangeValue() 
    338445    def devConfigChanged(self, idx): 
     446        if ffado.config.bypassdbus: 
     447            return True 
    339448        return self.iface.devConfigChanged(idx) 
    340449 
     
    351460        self.basepath=basepath 
    352461        self.servername=servername 
    353         self.bus=dbus.SessionBus() 
    354         self.dev = self.bus.get_object( self.servername, self.basepath ) 
    355         self.iface = dbus.Interface( self.dev, dbus_interface="org.ffado.Control.Element.Text" ) 
    356         self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element') 
     462        if ffado.config.bypassdbus: 
     463            self.devices = DeviceList(ffado.config.SYSTEM_CONFIG_FILE) 
     464            self.devices.updateFromFile(ffado.config.USER_CONFIG_FILE) 
     465        else: 
     466            self.bus=dbus.SessionBus() 
     467            self.dev = self.bus.get_object( self.servername, self.basepath ) 
     468            self.iface = dbus.Interface( self.dev, dbus_interface="org.ffado.Control.Element.Text" ) 
     469            self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element') 
    357470    def text(self): 
     471        if ffado.config.bypassdbus: 
     472            return "text" 
    358473        return self.iface.getValue() 
    359474    def setText(self,text): 
     475        if ffado.config.bypassdbus: 
     476            return 
    360477        self.iface.setValue(text) 
    361478    def canChangeValue(self): 
     479        if ffado.config.bypassdbus: 
     480            return True 
    362481        return self.iface_element.canChangeValue() 
    363482 
  • trunk/libffado/support/mixer-qt4/ffado/ffadowindow.py

    r2661 r2670  
    193193    get_lock('ffado-mixer') 
    194194 
     195    # Very simple command line option parser 
     196    if (len(args) > 1) and (args[1] == "-b" or args[1] == "--bypassdbus"): 
     197        ffado.config.bypassdbus = True 
     198 
    195199    # main loggers: 
    196200    logging.getLogger('main').setLevel(debug_level) 
  • trunk/libffado/support/mixer-qt4/ffado/mixer/profire2626.py

    r2653 r2670  
    2323import dbus 
    2424 
     25import ffado.config 
    2526from ffado.widgets.matrixmixer import MatrixMixer 
    2627from ffado.widgets.crossbarrouter import * 
     
    3132class BooleanControl: 
    3233    def __init__(self, hw, path): 
     34        if ffado.config.bypassdbus: 
     35            self.value = False 
     36            return 
    3337        self.iface = dbus.Interface( 
    3438                hw.bus.get_object(hw.servername, path), 
     
    4751class DiscreteControl: 
    4852    def __init__(self, hw, path): 
     53        if ffado.config.bypassdbus: 
     54            self.value = 0 
     55            return 
    4956        self.iface = dbus.Interface( 
    5057                hw.bus.get_object(hw.servername, path), 
  • trunk/libffado/support/mixer-qt4/ffado/mixer/saffire_dice.py

    r2669 r2670  
    3131class BooleanControl: 
    3232    def __init__(self, hw, path): 
     33        if bypassdbus: 
     34            self.value = False 
     35            return 
    3336        self.iface = dbus.Interface( 
    3437                hw.bus.get_object(hw.servername, path), 
     
    4043 
    4144    def select(self, n): 
     45        if bypassdbus: 
     46            return False 
    4247        if self.iface.select(n): 
    4348            self.value = n 
     
    4752class DiscreteControl: 
    4853    def __init__(self, hw, path): 
     54        if bypassdbus: 
     55            self.value = 0 
     56            return 
    4957        self.iface = dbus.Interface( 
    5058                hw.bus.get_object(hw.servername, path), 
     
    7280 
    7381        ModelName = self.configrom.getModelName() 
     82        if ffado.config.bypassdbus: 
     83            # A hack for the bypassdbus case, where ModelName has a slightly 
     84            # different format.  Rather than using the name as returned by 
     85            # the device (eg: "SAFFIRE_PRO_40"), the name is taken from the 
     86            # configuration file desciption (eg: "Saffire PRO 40"). 
     87            if ModelName[-2:] == "-1": 
     88                ModelName = ModelName[:-2] 
     89            if ModelName[-4:] == " DSP": 
     90                ModelName = ModelName[:-4] 
     91            ModelNum = ModelName[-2:] 
     92            ModelName = "SAFFIRE_PRO" 
     93            if ModelNum != "26": 
     94                ModelName += "_" 
     95            ModelName += ModelNum 
     96            print ModelName 
     97 
    7498        if  ModelName == "SAFFIRE_PRO_14": 
    7599            uicLoad("ffado/mixer/Saffire_Pro14_monitoring.ui", widget) 
  • trunk/libffado/support/mixer-qt4/ffado/panelmanager.py

    r2653 r2670  
    227227        log.debug("Adding device %d: %s" % (idx, path)) 
    228228 
    229         cfgrom = ConfigRomInterface(FFADO_DBUS_SERVER, FFADO_DBUS_BASEPATH+'/DeviceManager/'+path) 
     229        if ffado.config.bypassdbus: 
     230            cfgrom = ConfigRomInterface(FFADO_DBUS_SERVER, path) 
     231        else: 
     232            cfgrom = ConfigRomInterface(FFADO_DBUS_SERVER, FFADO_DBUS_BASEPATH+'/DeviceManager/'+path) 
    230233        vendorId = cfgrom.getVendorId() 
    231234        modelId = cfgrom.getModelId() 
     
    237240 
    238241        # check whether this has already been registered at ffado.org 
    239         reg = ffado_registration(FFADO_VERSION, int(guid, 16), 
    240                                      vendorId, modelId, 
    241                                      vendorName, modelName) 
    242         reg.check_for_registration() 
    243  
    244         # The MOTU devices use unitVersion to differentiate models.  For the 
    245         # moment though we don't need to know precisely which model we're 
    246         # using beyond it being a pre-mark3 (modelId=0) or mark3 (modelId=1)  
    247         # device. 
    248         if vendorId == 0x1f2: 
    249             # All MOTU devices with a unit version of 0x15 or greater are 
    250             # mark3 devices 
    251             if (unitVersion >= 0x15): 
    252                 modelId = 0x00000001 
    253             else: 
    254                 modelId = 0x00000000 
    255  
    256         # The RME devices use unitVersion to differentiate models.  
    257         # Therefore in the configuration file we use the config file's 
    258         # modelid field to store the unit version.  As a result we must 
    259         # override the modelId with the unit version here so the correct 
    260         # configuration file entry (and hense mixer widget) is identified. 
    261         if vendorId == 0xa35: 
    262             modelId = unitVersion; 
     242        if not ffado.config.bypassdbus: 
     243            reg = ffado_registration(FFADO_VERSION, int(guid, 16), 
     244                                         vendorId, modelId, 
     245                                         vendorName, modelName) 
     246            reg.check_for_registration() 
     247 
     248            # The MOTU devices use unitVersion to differentiate models.  For 
     249            # the moment though we don't need to know precisely which model 
     250            # we're using beyond it being a pre-mark3 (modelId=0) or mark3 
     251            # (modelId=1) device. 
     252            if vendorId == 0x1f2: 
     253                # All MOTU devices with a unit version of 0x15 or greater are 
     254                # mark3 devices 
     255                if (unitVersion >= 0x15): 
     256                    modelId = 0x00000001 
     257                else: 
     258                    modelId = 0x00000000 
     259 
     260            # The RME devices use unitVersion to differentiate models.  
     261            # Therefore in the configuration file we use the config file's 
     262            # modelid field to store the unit version.  As a result we must 
     263            # override the modelId with the unit version here so the correct 
     264            # configuration file entry (and hense mixer widget) is identified. 
     265            if vendorId == 0xa35: 
     266                modelId = unitVersion; 
    263267 
    264268        dev = self.devices.getDeviceById( vendorId, modelId ) 
     
    297301        if 'mixer' in dev and dev['mixer'] != None: 
    298302            mixerapp = dev['mixer'] 
     303            global mixerwidget 
    299304            exec( """ 
    300 import ffado.mixer.%s 
    301 mixerwidget = ffado.mixer.%s.%s( w ) 
    302 """ % (mixerapp.lower(), mixerapp.lower(), mixerapp) ) 
     305try: 
     306    import ffado.mixer.%s 
     307    globals()["mixerwidget"] = ffado.mixer.%s.%s( w ) 
     308    found = True 
     309except ImportError: 
     310    log.debug("bypassdbus set, %s module not available: ignored") 
     311    found = False 
     312""" % (mixerapp.lower(), mixerapp.lower(), mixerapp, mixerapp.lower()) ) 
    303313        else: 
     314            found = False 
     315 
     316        if not found: 
    304317            mixerwidget = Dummy( w ) 
    305318            mixerapp = modelName+" (Dummy)" 
     
    382395        for idx in range(nbDevices): 
    383396            path = self.devmgr.getDeviceName(idx) 
    384             cfgrom = ConfigRomInterface(FFADO_DBUS_SERVER, FFADO_DBUS_BASEPATH+'/DeviceManager/'+path) 
     397            if ffado.config.bypassdbus: 
     398                cfgrom = ConfigRomInterface(FFADO_DBUS_SERVER, path) 
     399            else: 
     400                cfgrom = ConfigRomInterface(FFADO_DBUS_SERVER, FFADO_DBUS_BASEPATH+'/DeviceManager/'+path) 
    385401            guid = cfgrom.getGUID() 
    386402            guids_present.append(guid) 
  • trunk/libffado/support/mixer-qt4/ffado/widgets/crossbarrouter.py

    r2665 r2670  
    2525from PyQt4.QtGui import QWidget, QVBoxLayout, QHBoxLayout, QPushButton 
    2626import dbus, math 
     27 
     28import ffado.config 
    2729 
    2830import logging 
     
    124126    def __init__(self, servername, basepath, parent=None): 
    125127        QWidget.__init__(self, parent); 
    126         self.bus = dbus.SessionBus() 
    127         self.dev = self.bus.get_object(servername, basepath) 
    128         self.interface = dbus.Interface(self.dev, dbus_interface="org.ffado.Control.Element.CrossbarRouter") 
     128        if not ffado.config.bypassdbus: 
     129            self.bus = dbus.SessionBus() 
     130            self.dev = self.bus.get_object(servername, basepath) 
     131            self.interface = dbus.Interface(self.dev, dbus_interface="org.ffado.Control.Element.CrossbarRouter") 
     132            self.destinations = self.interface.getDestinationNames() 
     133        else: 
     134            self.destinations = [] 
    129135 
    130136        self.settings = QtCore.QSettings(self) 
    131137 
    132         self.destinations = self.interface.getDestinationNames() 
    133138        self.outgroups = [] 
    134139        for ch in self.destinations: 
     
    179184    def updateLevels(self): 
    180185        #log.debug("CrossbarRouter.updateLevels()") 
     186        if ffado.config.bypassdbus: 
     187            return 
    181188        peakvalues = self.interface.getPeakValues() 
    182189        #log.debug("Got %i peaks" % len(peakvalues)) 
  • trunk/libffado/support/mixer-qt4/ffado/widgets/matrixmixer.py

    r2662 r2670  
    3030import dbus, math, decimal 
    3131 
     32import ffado.config 
     33 
    3234import logging 
    3335log = logging.getLogger("matrixmixer") 
     
    314316        QWidget.__init__(self, parent) 
    315317 
    316         self.bus = dbus.SessionBus() 
    317         self.dev = self.bus.get_object(servername, basepath) 
    318         self.interface = dbus.Interface(self.dev, dbus_interface="org.ffado.Control.Element.MatrixMixer") 
     318        if not ffado.config.bypassdbus: 
     319            self.bus = dbus.SessionBus() 
     320            self.dev = self.bus.get_object(servername, basepath) 
     321            self.interface = dbus.Interface(self.dev, dbus_interface="org.ffado.Control.Element.MatrixMixer") 
    319322 
    320323        self.transpose = transpose 
     
    322325            self.shortcolname = shortrowname 
    323326            self.shortrowname = shortcolname 
    324             self.cols = self.interface.getRowCount() 
    325             self.rows = self.interface.getColCount() 
     327            if ffado.config.bypassdbus: 
     328                self.cols = 2 
     329                self.rows = 2 
     330            else: 
     331                self.cols = self.interface.getRowCount() 
     332                self.rows = self.interface.getColCount() 
    326333        else: 
    327334            self.shortcolname = shortcolname 
    328335            self.shortrowname = shortrowname 
    329             self.cols = self.interface.getColCount() 
    330             self.rows = self.interface.getRowCount() 
     336            if ffado.config.bypassdbus: 
     337                self.cols = 2 
     338                self.rows = 2 
     339            else: 
     340                self.cols = self.interface.getColCount() 
     341                self.rows = self.interface.getRowCount() 
    331342 
    332343        log.debug("Mixer has %i rows and %i columns" % (self.rows, self.cols)) 
     
    334345        self.mutes_dev = None 
    335346        self.mutes_interface = None 
    336         if (mutespath != None): 
     347        if not ffado.config.bypassdbus and (mutespath != None): 
    337348            self.mutes_dev = self.bus.get_object(servername, mutespath) 
    338349            self.mutes_interface = dbus.Interface(self.mutes_dev, dbus_interface="org.ffado.Control.Element.MatrixMixer") 
     
    340351        self.inverts_dev = None 
    341352        self.inverts_interface = None 
    342         if (invertspath != None): 
     353        if not ffado.config.bypassdbus and (invertspath != None): 
    343354            self.inverts_dev = self.bus.get_object(servername, invertspath) 
    344355            self.inverts_interface = dbus.Interface(self.inverts_dev, dbus_interface="org.ffado.Control.Element.MatrixMixer") 
     
    381392                    if (self.inverts_interface != None): 
    382393                        inv_value = self.inverts_interface.getValue(j,i) 
    383                     node = MixerNode(i, j, self.interface.getValue(j,i), sliderMaxValue, mute_value, inv_value, self, self) 
     394                    if ffado.config.bypassdbus: 
     395                        val = 0 
     396                    else: 
     397                        val = self.interface.getValue(j,i) 
     398                    node = MixerNode(i, j, val, sliderMaxValue, mute_value, inv_value, self, self) 
    384399                else: 
    385400                    mute_value = None 
     
    389404                    if (self.inverts_interface != None): 
    390405                        inv_value = self.inverts_interface.getValue(i,j) 
    391                     node = MixerNode(j, i, self.interface.getValue(i,j), sliderMaxValue, mute_value, inv_value, self, self) 
     406                    if ffado.config.bypassdbus: 
     407                        val = 0 
     408                    else: 
     409                        val = self.interface.getValue(i,j) 
     410                    node = MixerNode(j, i, val, sliderMaxValue, mute_value, inv_value, self, self) 
    392411                if (smallFont): 
    393412                    font = node.font() 
     
    431450    # Columns and rows 
    432451    def getColName(self, i, shortname): 
     452        if ffado.config.bypassdbus: 
     453            return 'col ' + str(i) 
    433454        if (self.transpose): 
    434455            name = self.interface.getRowName(i) 
     
    442463 
    443464    def getRowName(self, j, shortname): 
     465        if ffado.config.bypassdbus: 
     466            return 'row ' + str(j) 
    444467        if (self.transpose): 
    445468            name = self.interface.getColName(j) 
     
    454477    def valueChangedFn(self, n): 
    455478        #log.debug("MatrixNode.valueChangedFn( %s )" % str(n)) 
    456         self.interface.setValue(n[1], n[0], n[2]) 
     479        if not ffado.config.bypassdbus: 
     480            self.interface.setValue(n[1], n[0], n[2]) 
    457481        self.valueChanged.emit(n) 
    458482         
     
    488512 
    489513    def refreshValues(self): 
     514        if ffado.config.bypassdbus: 
     515            return 
    490516        for x in range(len(self.items)): 
    491517            for y in range(len(self.items[x])): 
     
    754780        QWidget.__init__(self, parent) 
    755781 
    756         self.bus = dbus.SessionBus() 
    757         self.dev = self.bus.get_object(servername, basepath) 
    758         self.interface = dbus.Interface(self.dev, dbus_interface="org.ffado.Control.Element.MatrixMixer") 
     782        if not ffado.config.bypassdbus: 
     783            self.bus = dbus.SessionBus() 
     784            self.dev = self.bus.get_object(servername, basepath) 
     785            self.interface = dbus.Interface(self.dev, dbus_interface="org.ffado.Control.Element.MatrixMixer") 
    759786 
    760787        self.rule = rule 
     
    860887 
    861888    def getNbIn(self): 
     889        if ffado.config.bypassdbus: 
     890            return 2 
    862891        if (self.rule == "Columns_are_inputs"): 
    863892            return self.interface.getColCount() 
     
    866895         
    867896    def getNbOut(self): 
     897        if ffado.config.bypassdbus: 
     898            return 2 
    868899        if (self.rule == "Columns_are_inputs"): 
    869900            nbout = self.interface.getRowCount() 
     
    873904         
    874905    def getVolumeValue(self, In, i): 
     906        if ffado.config.bypassdbus: 
     907            return 1 
    875908        Out = self.out[i].out_1 
    876909        if (self.rule == "Columns_are_inputs"): 
     
    888921 
    889922    def getBalanceValue(self, In, i): 
     923        if ffado.config.bypassdbus: 
     924            return 0.5 
    890925        Out = self.out[i].out_1 
    891926        if (self.rule == "Columns_are_inputs"): 
     
    898933 
    899934    def setValue(self, In, Out, val): 
     935        if ffado.config.bypassdbus: 
     936            return 
    900937        if (self.rule == "Columns_are_inputs"): 
    901938            return self.interface.setValue(Out, In, val)            
     
    9721009            return name 
    9731010        else: 
     1011            if ffado.config.bypassdbus: 
     1012                return 'OutName ' + str(i) 
    9741013            if (self.rule == "Columns_are_inputs"):                 
    9751014                if (self.out[i].is_stereo): 
     
    9921031            return name 
    9931032        else: 
     1033            if ffado.config.bypassdbus: 
     1034                return 'InName ' + str(j) 
    9941035            if (self.rule == "Columns_are_inputs"): 
    9951036                return self.interface.getColName(j)             
     
    10331074 
    10341075    def saveSettings(self, indent): 
    1035         rows = self.interface.getRowCount() 
    1036         cols = self.interface.getColCount() 
     1076        if ffado.config.bypassdbus: 
     1077            rows = 2 
     1078            cols = 2 
     1079        else: 
     1080            rows = self.interface.getRowCount() 
     1081            cols = self.interface.getColCount() 
    10371082        matrixSaveString = [] 
    10381083        matrixSaveString.append('%s  <row_number>\n' % indent) 
     
    10541099 
    10551100    def readSettings(self, readMatrixString, transpose_coeff): 
    1056         rows = self.interface.getRowCount() 
    1057         cols = self.interface.getColCount() 
     1101        if ffado.config.bypassdbus: 
     1102            rows = 2 
     1103            cols = 2 
     1104        else: 
     1105            rows = self.interface.getRowCount() 
     1106            cols = self.interface.getColCount() 
    10581107        if readMatrixString[0].find("<row_number>") == -1: 
    10591108            log.debug("Number of matrix rows must be specified")