src/bindings/python/Shairplay.py

   1 # coding=utf-8
   2 '''
   3 Copyright (C) 2012  Juho Vähä-Herttua
   4
   5 Permission is hereby granted, free of charge, to any person obtaining
   6 a copy of this software and associated documentation files (the
   7 "Software"), to deal in the Software without restriction, including
   8 without limitation the rights to use, copy, modify, merge, publish,
   9 distribute, sublicense, and/or sell copies of the Software, and to
  10 permit persons to whom the Software is furnished to do so, subject to
  11 the following conditions:
  12
  13 The above copyright notice and this permission notice shall be included
  14 in all copies or substantial portions of the Software.
  15
  16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  19 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  20 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  21 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  22 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23 '''
  24
  25 import os
  26 import sys
  27 import platform
  28
  29 from ctypes import *
  30
  31 class RaopLogLevel:
  32         EMERG   = 0
  33         ALERT   = 1
  34         CRIT    = 2
  35         ERR     = 3
  36         WARNING = 4
  37         NOTICE  = 5
  38         INFO    = 6
  39         DEBUG   = 7
  40
  41 raop_log_callback_prototype =   CFUNCTYPE(None, c_int, c_char_p)
  42
  43 audio_init_prototype =          CFUNCTYPE(py_object, c_void_p, c_int, c_int, c_int)
  44 audio_process_prototype =       CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_int)
  45 audio_destroy_prototype =       CFUNCTYPE(None, c_void_p, c_void_p)
  46
  47 audio_flush_prototype =         CFUNCTYPE(None, c_void_p, c_void_p)
  48 audio_set_volume_prototype =    CFUNCTYPE(None, c_void_p, c_void_p, c_float)
  49 audio_set_metadata_prototype =  CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_int)
  50 audio_set_coverart_prototype =  CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_int)
  51
  52 class RaopNativeCallbacks(Structure):
  53         _fields_ = [("cls",                 py_object),
  54                     ("audio_init",          audio_init_prototype),
  55                     ("audio_process",       audio_process_prototype),
  56                     ("audio_destroy",       audio_destroy_prototype),
  57                     ("audio_flush",         audio_flush_prototype),
  58                     ("audio_set_volume",    audio_set_volume_prototype),
  59                     ("audio_set_metadata",  audio_set_metadata_prototype),
  60                     ("audio_set_coverart",  audio_set_coverart_prototype)]
  61
  62 def InitShairplay(libshairplay):
  63         # Initialize dnssd related functions
  64         libshairplay.dnssd_init.restype = c_void_p
  65         libshairplay.dnssd_init.argtypes = [POINTER(c_int)]
  66         libshairplay.dnssd_register_raop.restype = c_int
  67         libshairplay.dnssd_register_raop.argtypes = [c_void_p, c_char_p, c_ushort, POINTER(c_char), c_int, c_int]
  68         libshairplay.dnssd_register_airplay.restype = c_int
  69         libshairplay.dnssd_register_airplay.argtypes = [c_void_p, c_char_p, c_ushort, POINTER(c_char), c_int]
  70         libshairplay.dnssd_unregister_raop.restype = None
  71         libshairplay.dnssd_unregister_raop.argtypes = [c_void_p]
  72         libshairplay.dnssd_unregister_airplay.restype = None
  73         libshairplay.dnssd_unregister_airplay.argtypes = [c_void_p]
  74         libshairplay.dnssd_destroy.restype = None
  75         libshairplay.dnssd_destroy.argtypes = [c_void_p]
  76
  77         # Initialize raop related functions
  78         libshairplay.raop_init.restype = c_void_p
  79         libshairplay.raop_init.argtypes = [c_int, POINTER(RaopNativeCallbacks), c_char_p]
  80         libshairplay.raop_set_log_level.restype = None
  81         libshairplay.raop_set_log_level.argtypes = [c_void_p, c_int]
  82         libshairplay.raop_set_log_callback.restype = None
  83         libshairplay.raop_set_log_callback.argtypes = [c_void_p, raop_log_callback_prototype]
  84         libshairplay.raop_is_running.restype = c_int
  85         libshairplay.raop_is_running.argtypes = [c_void_p]
  86         libshairplay.raop_start.restype = c_int
  87         libshairplay.raop_start.argtypes = [c_void_p, POINTER(c_ushort), POINTER(c_char), c_int, c_char_p]
  88         libshairplay.raop_stop.restype = None
  89         libshairplay.raop_stop.argtypes = [c_void_p]
  90         libshairplay.raop_destroy.restype = None
  91         libshairplay.raop_destroy.argtypes = [c_void_p]
  92
  93 def LoadShairplay(path):
  94         if sys.maxsize < 2**32:
  95                 libname = "shairplay32"
  96         else:
  97                 libname = "shairplay64"
  98
  99         if platform.system() == "Windows":
 100                 libname = libname + ".dll"
 101         elif platform.system() == "Darwin":
 102                 libname = "lib" + libname + ".dylib"
 103         else:
 104                 libname = "lib" + libname + ".so"
 105
 106         try:
 107                 fullpath = os.path.join(path, libname)
 108                 libshairplay = cdll.LoadLibrary(fullpath)
 109         except:
 110                 raise RuntimeError("Couldn't load shairplay library " + libname)
 111
 112         InitShairplay(libshairplay)
 113         return libshairplay
 114
 115 RSA_KEY = """
 116 -----BEGIN RSA PRIVATE KEY-----
 117 MIIEpQIBAAKCAQEA59dE8qLieItsH1WgjrcFRKj6eUWqi+bGLOX1HL3U3GhC/j0Qg90u3sG/1CUt
 118 wC5vOYvfDmFI6oSFXi5ELabWJmT2dKHzBJKa3k9ok+8t9ucRqMd6DZHJ2YCCLlDRKSKv6kDqnw4U
 119 wPdpOMXziC/AMj3Z/lUVX1G7WSHCAWKf1zNS1eLvqr+boEjXuBOitnZ/bDzPHrTOZz0Dew0uowxf
 120 /+sG+NCK3eQJVxqcaJ/vEHKIVd2M+5qL71yJQ+87X6oV3eaYvt3zWZYD6z5vYTcrtij2VZ9Zmni/
 121 UAaHqn9JdsBWLUEpVviYnhimNVvYFZeCXg/IdTQ+x4IRdiXNv5hEewIDAQABAoIBAQDl8Axy9XfW
 122 BLmkzkEiqoSwF0PsmVrPzH9KsnwLGH+QZlvjWd8SWYGN7u1507HvhF5N3drJoVU3O14nDY4TFQAa
 123 LlJ9VM35AApXaLyY1ERrN7u9ALKd2LUwYhM7Km539O4yUFYikE2nIPscEsA5ltpxOgUGCY7b7ez5
 124 NtD6nL1ZKauw7aNXmVAvmJTcuPxWmoktF3gDJKK2wxZuNGcJE0uFQEG4Z3BrWP7yoNuSK3dii2jm
 125 lpPHr0O/KnPQtzI3eguhe0TwUem/eYSdyzMyVx/YpwkzwtYL3sR5k0o9rKQLtvLzfAqdBxBurciz
 126 aaA/L0HIgAmOit1GJA2saMxTVPNhAoGBAPfgv1oeZxgxmotiCcMXFEQEWflzhWYTsXrhUIuz5jFu
 127 a39GLS99ZEErhLdrwj8rDDViRVJ5skOp9zFvlYAHs0xh92ji1E7V/ysnKBfsMrPkk5KSKPrnjndM
 128 oPdevWnVkgJ5jxFuNgxkOLMuG9i53B4yMvDTCRiIPMQ++N2iLDaRAoGBAO9v//mU8eVkQaoANf0Z
 129 oMjW8CN4xwWA2cSEIHkd9AfFkftuv8oyLDCG3ZAf0vrhrrtkrfa7ef+AUb69DNggq4mHQAYBp7L+
 130 k5DKzJrKuO0r+R0YbY9pZD1+/g9dVt91d6LQNepUE/yY2PP5CNoFmjedpLHMOPFdVgqDzDFxU8hL
 131 AoGBANDrr7xAJbqBjHVwIzQ4To9pb4BNeqDndk5Qe7fT3+/H1njGaC0/rXE0Qb7q5ySgnsCb3DvA
 132 cJyRM9SJ7OKlGt0FMSdJD5KG0XPIpAVNwgpXXH5MDJg09KHeh0kXo+QA6viFBi21y340NonnEfdf
 133 54PX4ZGS/Xac1UK+pLkBB+zRAoGAf0AY3H3qKS2lMEI4bzEFoHeK3G895pDaK3TFBVmD7fV0Zhov
 134 17fegFPMwOII8MisYm9ZfT2Z0s5Ro3s5rkt+nvLAdfC/PYPKzTLalpGSwomSNYJcB9HNMlmhkGzc
 135 1JnLYT4iyUyx6pcZBmCd8bD0iwY/FzcgNDaUmbX9+XDvRA0CgYEAkE7pIPlE71qvfJQgoA9em0gI
 136 LAuE4Pu13aKiJnfft7hIjbK+5kyb3TysZvoyDnb3HOKvInK7vXbKuU4ISgxB2bB3HcYzQMGsz1qJ
 137 2gG0N5hvJpzwwhbhXqFKA4zaaSrw622wDniAK5MlIE0tIAKKP4yxNGjoD2QYjhBGuhvkWKY=
 138 -----END RSA PRIVATE KEY-----
 139 """
 140
 141 class RaopCallbacks:
 142         def audio_init(self, bits, channels, samplerate):
 143                 raise NotImplementedError()
 144
 145         def audio_process(self, session, buffer):
 146                 raise NotImplementedError()
 147
 148         def audio_destroy(self, session):
 149                 raise NotImplementedError()
 150
 151         def audio_set_volume(self, session, volume):
 152                 pass
 153
 154         def audio_flush(self, session):
 155                 pass
 156
 157         def audio_set_metadata(self, session, buffer):
 158                 pass
 159
 160         def audio_set_coverart(self, session, buffer):
 161                 pass
 162
 163 class RaopService:
 164         def log_callback_cb(self, level, message):
 165                 if self.log_callback != None:
 166                         self.log_callback(level, message)
 167                 else:
 168                         print message
 169
 170         def audio_init_cb(self, cls, bits, channels, samplerate):
 171                 session = self.callbacks.audio_init(bits, channels, samplerate)
 172                 self.sessions.append(session)
 173                 return session
 174
 175         def audio_process_cb(self, cls, sessionptr, buffer, buflen):
 176                 session = cast(sessionptr, py_object).value
 177                 strbuffer = string_at(buffer, buflen)
 178                 self.callbacks.audio_process(session, strbuffer)
 179
 180         def audio_destroy_cb(self, cls, sessionptr):
 181                 session = cast(sessionptr, py_object).value
 182                 self.callbacks.audio_destroy(session)
 183                 if session in self.sessions:
 184                         self.sessions.remove(session)
 185
 186         def audio_flush_cb(self, cls, sessionptr):
 187                 session = cast(sessionptr, py_object).value
 188                 self.callbacks.audio_flush(session)
 189
 190         def audio_set_volume_cb(self, cls, sessionptr, volume):
 191                 session = cast(sessionptr, py_object).value
 192                 self.callbacks.audio_set_volume(session, volume)
 193
 194         def audio_set_metadata_cb(self, cls, sessionptr, buffer, buflen):
 195                 session = cast(sessionptr, py_object).value
 196                 strbuffer = string_at(buffer, buflen)
 197                 self.callbacks.audio_set_metadata(session, strbuffer)
 198
 199         def audio_set_coverart_cb(self, cls, sessionptr, buffer, buflen):
 200                 session = cast(sessionptr, py_object).value
 201                 strbuffer = string_at(buffer, buflen)
 202                 self.callbacks.audio_set_coverart(session, strbuffer)
 203
 204
 205         def __init__(self, libshairplay, max_clients, callbacks):
 206                 self.libshairplay = libshairplay
 207                 self.callbacks = callbacks
 208                 self.sessions = []
 209                 self.instance = None
 210
 211                 # We need to hold a reference to native_callbacks
 212                 self.native_callbacks = RaopNativeCallbacks()
 213                 self.native_callbacks.audio_init = audio_init_prototype(self.audio_init_cb)
 214                 self.native_callbacks.audio_process = audio_process_prototype(self.audio_process_cb)
 215                 self.native_callbacks.audio_destroy = audio_destroy_prototype(self.audio_destroy_cb)
 216                 self.native_callbacks.audio_flush = audio_flush_prototype(self.audio_flush_cb)
 217                 self.native_callbacks.audio_set_volume = audio_set_volume_prototype(self.audio_set_volume_cb)
 218                 self.native_callbacks.audio_set_metadata = audio_set_metadata_prototype(self.audio_set_metadata_cb)
 219                 self.native_callbacks.audio_set_coverart = audio_set_coverart_prototype(self.audio_set_coverart_cb)
 220
 221                 # Initialize the raop instance with our callbacks
 222                 self.instance = self.libshairplay.raop_init(max_clients, pointer(self.native_callbacks), RSA_KEY)
 223                 if self.instance == None:
 224                         raise RuntimeError("Initializing library failed")
 225
 226                 # We need to hold a reference to the log callback wrapper
 227                 self.log_callback_pointer = raop_log_callback_prototype(self.log_callback_cb)
 228                 self.libshairplay.raop_set_log_callback(self.instance, self.log_callback_pointer)
 229                 self.log_callback = None
 230
 231         def __del__(self):
 232                 if self.instance != None:
 233                         self.libshairplay.raop_destroy(self.instance)
 234                 self.instance = None
 235
 236         def is_running(self):
 237                 if self.libshairplay.raop_is_running(self.instance):
 238                         return True
 239                 else:
 240                         return False
 241
 242         def set_log_level(self, level):
 243                 self.libshairplay.raop_set_log_level(self.instance, level)
 244
 245         def set_log_callback(self, log_callback):
 246                 self.log_callback = log_callback
 247
 248         def start(self, port, hwaddrstr, password=None):
 249                 port = c_ushort(port)
 250                 hwaddr = create_string_buffer(hwaddrstr, len(hwaddrstr))
 251
 252                 ret = self.libshairplay.raop_start(self.instance, pointer(port), hwaddr, c_int(len(hwaddr)), password)
 253                 if ret < 0:
 254                         raise RuntimeError("Starting RAOP instance failed")
 255                 return port.value
 256
 257         def stop(self):
 258                 self.libshairplay.raop_stop(self.instance)
 259
 260 class DnssdService:
 261         def __init__(self, libshairplay):
 262                 self.libshairplay = libshairplay
 263                 self.instance = None
 264
 265                 error = c_int(0)
 266
 267                 self.instance = self.libshairplay.dnssd_init(pointer(error))
 268                 if self.instance == None:
 269                         raise RuntimeError("Initializing library failed: " + str(error.value))
 270
 271         def __del__(self):
 272                 if self.instance != None:
 273                         self.libshairplay.dnssd_destroy(self.instance)
 274                 self.instance = None
 275
 276         def register_raop(self, name, port, hwaddrstr, password=False):
 277                 hwaddr = create_string_buffer(hwaddrstr, len(hwaddrstr))
 278                 use_pw = c_int(0)
 279                 if password:
 280                         use_pw = c_int(1)
 281                 self.libshairplay.dnssd_register_raop(self.instance, name, c_ushort(port), hwaddr, len(hwaddr), use_pw)
 282
 283         def unregister_raop(self):
 284                 self.libshairplay.dnssd_unregister_raop(self.instance)
 285
 286         def register_airplay(self, name, port, hwaddrstr):
 287                 hwaddr = create_string_buffer(hwaddrstr, len(hwaddrstr))
 288                 self.libshairplay.dnssd_register_airplay(self.instance, name, c_ushort(port), hwaddr, len(hwaddr))
 289
 290         def unregister_airplay(self):
 291                 self.libshairplay.dnssd_unregister_airplay(self.instance)
 292