example-clients/jack_control

   1 #!/usr/bin/env python
   2
   3 name_base = 'org.jackaudio'
   4 control_interface_name = name_base + '.JackControl'
   5 configure_interface_name = name_base + '.Configure'
   6 service_name = name_base + '.service'
   7
   8 import sys
   9 import os
  10 from traceback import print_exc
  11
  12 import dbus
  13
  14 def bool_convert(str_value):
  15     if str_value.lower() == "false":
  16         return False
  17
  18     if str_value.lower() == "off":
  19         return False
  20
  21     if str_value.lower() == "no":
  22         return False
  23
  24     if str_value == "0":
  25         return False
  26
  27     if str_value.lower() == "(null)":
  28         return False
  29
  30     return bool(str_value)
  31
  32 def dbus_type_to_python_type(dbus_value):
  33     if type(dbus_value) == dbus.Boolean:
  34         return bool(dbus_value)
  35     if type(dbus_value) == dbus.Int32 or type(dbus_value) == dbus.UInt32:
  36         return int(dbus_value)
  37     return dbus_value
  38
  39 def python_type_to_jackdbus_type(value, type_char):
  40     type_char = str(type_char)
  41
  42     if type_char == "b":
  43         return bool_convert(value);
  44     elif type_char == "y":
  45         return dbus.Byte(value);
  46     elif type_char == "i":
  47         return dbus.Int32(value)
  48     elif type_char == "u":
  49         return dbus.UInt32(value)
  50
  51     return value
  52
  53 def dbus_type_to_type_string(dbus_value):
  54     if type(dbus_value) == dbus.Boolean:
  55         return "bool"
  56     if type(dbus_value) == dbus.Int32:
  57         return "sint"
  58     if type(dbus_value) == dbus.UInt32:
  59         return "uint"
  60     if type(dbus_value) == dbus.Byte:
  61         return "char"
  62     if type(dbus_value) == dbus.String:
  63         return "str"
  64
  65     return None                         # throw exception here?
  66
  67 def dbus_typesig_to_type_string(type_char):
  68     type_char = str(type_char)
  69     if type_char == 'i':
  70         return "sint"
  71     if type_char == 'u':
  72         return "uint"
  73     if type_char == 'y':
  74         return "char"
  75     if type_char == 's':
  76         return "str"
  77     if type_char == 'b':
  78         return "bool"
  79
  80     print 'shit'
  81     return None                         # throw exception here?
  82
  83 def get_parameters(iface, path):
  84     params = iface.GetParametersInfo(path)
  85
  86     #print params
  87     for param in params:
  88         typestr = dbus_typesig_to_type_string(param[0])
  89         name = param[1]
  90         #print name
  91         descr = param[2]
  92         #print descr
  93         isset, default, value = iface.GetParameterValue(path + [name])
  94         #print typestr
  95         if bool(isset):
  96             isset = "set"
  97         else:
  98             isset = "notset"
  99         value = dbus_type_to_python_type(value)
 100         default = dbus_type_to_python_type(default)
 101
 102         print "%20s: %s (%s:%s:%s:%s)" %(name, descr, typestr, isset, default, value)
 103
 104 def main():
 105     if len(sys.argv) == 1:
 106         print "Usage: %s [command] [command] ..." % os.path.basename(sys.argv[0])
 107         print "Commands:"
 108         print "    exit                       - exit jack dbus service (stops jack server if currently running)"
 109         print "    status                     - check whether jack server is started, return value is 0 if running and 1 otherwise"
 110         print "    start                      - start jack server if not currently started"
 111         print "    stop                       - stop jack server if currently started"
 112         print "    sm                         - switch master to currently selected driver"
 113         print "    dl                         - get list of available drivers"
 114         print "    dg                         - get currently selected driver"
 115         print "    ds <driver>                - select driver"
 116         print "    dp                         - get parameters of currently selected driver"
 117         print "    dpd <param>                - get long description for driver parameter"
 118         print "    dps <param> <value>        - set driver parameter"
 119         print "    dpr <param>                - reset driver parameter to its default value"
 120         print "    asd <driver>               - add slave driver"
 121         print "    rsd <driver>               - remove slave driver"
 122         print "    il                         - get list of available internals"
 123         print "    ip <name>                  - get parameters of given internal"
 124         print "    ipd <name> <param>         - get long description for internal parameter"
 125         print "    ips <name> <param> <value> - set internal parameter"
 126         print "    ipr <name> <param>         - reset internal parameter to its default value"
 127         print "    iload <name>               - load internal"
 128         print "    iunload <name>             - unload internal"
 129         print "    ep                         - get engine parameters"
 130         print "    epd <param>                - get long description for engine parameter"
 131         print "    eps <param> <value>        - set engine parameter"
 132         print "    epr <param>                - reset engine parameter to its default value"
 133         sys.exit(0)
 134
 135     bus = dbus.SessionBus()
 136
 137     controller = bus.get_object(service_name, "/org/jackaudio/Controller")
 138     control_iface = dbus.Interface(controller, control_interface_name)
 139     configure_iface = dbus.Interface(controller, configure_interface_name)
 140
 141     # check arguments
 142     index = 1
 143     while index < len(sys.argv):
 144         arg = sys.argv[index]
 145         index += 1
 146         try:
 147             if arg == "exit":
 148                 print "--- exit"
 149                 control_iface.Exit()
 150             elif arg == "status":
 151                 print "--- status"
 152                 if control_iface.IsStarted():
 153                     print "started"
 154                     sys.exit(0)
 155                 else:
 156                     print "stopped"
 157                     sys.exit(1)
 158             elif arg == 'start':
 159                 print "--- start"
 160                 control_iface.StartServer()
 161             elif arg == 'stop':
 162                 print "--- stop"
 163                 control_iface.StopServer()
 164             elif arg == 'sm':
 165                 print "--- switch master driver"
 166                 control_iface.SwitchMaster()
 167             elif arg == 'ism':
 168                 if control_iface.IsManuallyActivated():
 169                     print "Manually activated"
 170                 else:
 171                     print "Automatically activated"
 172             elif arg == 'dl':
 173                 print "--- drivers list"
 174                 is_range, is_strict, is_fake_values, values = configure_iface.GetParameterConstraint(['engine', 'driver'])
 175                 for value in values:
 176                     print value[1]
 177             elif arg == 'dg':
 178                 print "--- get selected driver"
 179                 isset, default, value = configure_iface.GetParameterValue(['engine', 'driver'])
 180                 print value
 181             elif arg == 'ds':
 182                 if index >= len(sys.argv):
 183                     print "driver select command requires driver name argument"
 184                     sys.exit()
 185
 186                 arg = sys.argv[index]
 187                 index += 1
 188
 189                 print "--- driver select \"%s\"" % arg
 190                 configure_iface.SetParameterValue(['engine', 'driver'], dbus.String(arg))
 191             elif arg == 'dp':
 192                 print "--- get driver parameters (type:isset:default:value)"
 193                 get_parameters(configure_iface, ['driver'])
 194             elif arg == 'dpd':
 195                 if index >= len(sys.argv):
 196                     print "get driver parameter long description command requires parameter name argument"
 197                     sys.exit()
 198
 199                 param = sys.argv[index]
 200                 index += 1
 201
 202                 print "--- get driver parameter description (%s)" % param
 203                 type_char, name, short_descr, long_descr = configure_iface.GetParameterInfo(['driver', param])
 204                 print long_descr,
 205             elif arg == 'dps':
 206                 if index + 1 >= len(sys.argv):
 207                     print "driver parameter set command requires parameter name and value arguments"
 208                     sys.exit()
 209
 210                 param = sys.argv[index]
 211                 index += 1
 212                 value = sys.argv[index]
 213                 index += 1
 214
 215                 print "--- driver param set \"%s\" -> \"%s\"" % (param, value)
 216
 217                 type_char, name, short_descr, long_descr = configure_iface.GetParameterInfo(['driver', param])
 218                 configure_iface.SetParameterValue(['driver', param], python_type_to_jackdbus_type(value, type_char))
 219             elif arg == 'dpr':
 220                 if index >= len(sys.argv):
 221                     print "driver parameter reset command requires parameter name argument"
 222                     sys.exit()
 223
 224                 param = sys.argv[index]
 225                 index += 1
 226
 227                 print "--- driver param reset \"%s\"" % param
 228                 configure_iface.ResetParameterValue(['driver', param])
 229             elif arg == 'ep':
 230                 print "--- get engine parameters (type:isset:default:value)"
 231                 get_parameters(configure_iface, ['engine'])
 232             elif arg == 'epd':
 233                 if index >= len(sys.argv):
 234                     print "get engine parameter long description command requires parameter name argument"
 235                     sys.exit()
 236
 237                 param_name = sys.argv[index]
 238                 index += 1
 239
 240                 print "--- get engine parameter description (%s)" % param_name
 241
 242                 type_char, name, short_descr, long_descr = configure_iface.GetParameterInfo(['engine', param_name])
 243                 print long_descr,
 244             elif arg == 'eps':
 245                 if index + 1 >= len(sys.argv):
 246                     print "engine parameter set command requires parameter name and value arguments"
 247                     sys.exit()
 248
 249                 param = sys.argv[index]
 250                 index += 1
 251                 value = sys.argv[index]
 252                 index += 1
 253
 254                 print "--- engine param set \"%s\" -> \"%s\"" % (param, value)
 255
 256                 type_char, name, short_descr, long_descr = configure_iface.GetParameterInfo(['engine', param])
 257                 configure_iface.SetParameterValue(['engine', param], python_type_to_jackdbus_type(value, type_char))
 258             elif arg == 'epr':
 259                 if index >= len(sys.argv):
 260                     print "engine parameter reset command requires parameter name"
 261                     sys.exit()
 262
 263                 param = sys.argv[index]
 264                 index += 1
 265
 266                 print "--- engine param reset \"%s\"" % param
 267
 268                 type_char, name, short_descr, long_descr = configure_iface.GetParameterInfo(['engine', param])
 269                 configure_iface.ResetParameterValue(['engine', param])
 270             elif arg == 'il':
 271                 print "--- internals list"
 272                 is_leaf, internals = configure_iface.ReadContainer(['internals'])
 273                 for internal in internals:
 274                     print internal
 275             elif arg == 'ip':
 276                 print "--- get internal parameters (type:isset:default:value)"
 277
 278                 if index >= len(sys.argv):
 279                     print "internal parameters command requires internal name argument"
 280                     sys.exit()
 281
 282                 internal_name = sys.argv[index]
 283                 index += 1
 284
 285                 get_parameters(configure_iface, ['internals', internal_name])
 286             elif arg == 'ipd':
 287                 if index + 1 >= len(sys.argv):
 288                     print "get internal parameter long description command requires internal and parameter name arguments"
 289                     sys.exit()
 290
 291                 name = sys.argv[index]
 292                 index += 1
 293                 param = sys.argv[index]
 294                 index += 1
 295
 296                 print "--- get internal parameter description (%s)" % param
 297                 type_char, name, short_descr, long_descr = configure_iface.GetParameterInfo(['internals', name, param])
 298                 print long_descr
 299             elif arg == 'ips':
 300                 if index + 2 >= len(sys.argv):
 301                     print "internal parameter set command requires internal, parameter name and value arguments"
 302                     sys.exit()
 303
 304                 internal_name = sys.argv[index]
 305                 index += 1
 306                 param = sys.argv[index]
 307                 index += 1
 308                 value = sys.argv[index]
 309                 index += 1
 310
 311                 print "--- internal param set \"%s\" -> \"%s\"" % (param, value)
 312
 313                 type_char, name, short_descr, long_descr = configure_iface.GetParameterInfo(['internals', internal_name, param])
 314                 configure_iface.SetParameterValue(['internals', internal_name, param], python_type_to_jackdbus_type(value, type_char))
 315             elif arg == 'ipr':
 316                 if index + 1 >= len(sys.argv):
 317                     print "reset internal parameter command requires internal and parameter name arguments"
 318                     sys.exit()
 319
 320                 internal_name = sys.argv[index]
 321                 index += 1
 322                 param = sys.argv[index]
 323                 index += 1
 324
 325                 print "--- internal param reset \"%s\"" % param
 326
 327                 configure_iface.ResetParameterValue(['internals', internal_name, param])
 328             elif arg == 'iload':
 329                 print "--- load internal"
 330
 331                 if index >= len(sys.argv):
 332                     print "load internal command requires internal name argument"
 333                     sys.exit()
 334
 335                 name = sys.argv[index]
 336                 index += 1
 337                 result = control_iface.LoadInternal(name)
 338             elif arg == 'iunload':
 339                 print "--- unload internal"
 340
 341                 if index >= len(sys.argv):
 342                     print "unload internal command requires internal name argument"
 343                     sys.exit()
 344
 345                 name = sys.argv[index]
 346                 index += 1
 347                 result = control_iface.UnloadInternal(name)
 348             elif arg == 'asd':
 349                 print "--- add slave driver"
 350
 351                 if index >= len(sys.argv):
 352                     print "add slave driver command requires driver name argument"
 353                     sys.exit()
 354
 355                 name = sys.argv[index]
 356                 index += 1
 357                 result = control_iface.AddSlaveDriver(name)
 358             elif arg == 'rsd':
 359                 print "--- remove slave driver"
 360
 361                 if index >= len(sys.argv):
 362                     print "remove slave driver command requires driver name argument"
 363                     sys.exit()
 364
 365                 name = sys.argv[index]
 366                 index += 1
 367                 result = control_iface.RemoveSlaveDriver(name)
 368             else:
 369                 print "Unknown command '%s'" % arg
 370         except dbus.DBusException, e:
 371             print "DBus exception: %s" % str(e)
 372
 373 if __name__ == '__main__':
 374     main()