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 audio_init_prototype =        CFUNCTYPE(py_object, c_void_p, c_int, c_int, c_int)
  32 audio_set_volume_prototype =  CFUNCTYPE(None, c_void_p, c_void_p, c_float)
  33 audio_process_prototype =     CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_int)
  34 audio_flush_prototype =       CFUNCTYPE(None, c_void_p, c_void_p)
  35 audio_destroy_prototype =     CFUNCTYPE(None, c_void_p, c_void_p)
  36
  37 class RaopNativeCallbacks(Structure):
  38         _fields_ = [("cls",               py_object),
  39                     ("audio_init",        audio_init_prototype),
  40                     ("audio_set_volume",  audio_set_volume_prototype),
  41                     ("audio_process",     audio_process_prototype),
  42                     ("audio_flush",       audio_flush_prototype),
  43                     ("audio_destroy",     audio_destroy_prototype)]
  44
  45 def InitShairplay(libshairplay):
  46         # Initialize dnssd related functions
  47         libshairplay.dnssd_init.restype = c_void_p
  48         libshairplay.dnssd_init.argtypes = [POINTER(c_int)]
  49         libshairplay.dnssd_register_raop.restype = c_int
  50         libshairplay.dnssd_register_raop.argtypes = [c_void_p, c_char_p, c_ushort, POINTER(c_char), c_int, c_int]
  51         libshairplay.dnssd_register_airplay.restype = c_int
  52         libshairplay.dnssd_register_airplay.argtypes = [c_void_p, c_char_p, c_ushort, POINTER(c_char), c_int]
  53         libshairplay.dnssd_unregister_raop.restype = None
  54         libshairplay.dnssd_unregister_raop.argtypes = [c_void_p]
  55         libshairplay.dnssd_unregister_airplay.restype = None
  56         libshairplay.dnssd_unregister_airplay.argtypes = [c_void_p]
  57         libshairplay.dnssd_destroy.restype = None
  58         libshairplay.dnssd_destroy.argtypes = [c_void_p]
  59
  60         # Initialize raop related functions
  61         libshairplay.raop_init.restype = c_void_p
  62         libshairplay.raop_init.argtypes = [POINTER(RaopNativeCallbacks), c_char_p]
  63         libshairplay.raop_start.restype = c_int
  64         libshairplay.raop_start.argtypes = [c_void_p, POINTER(c_ushort), POINTER(c_char), c_int, c_char_p]
  65         libshairplay.raop_stop.restype = None
  66         libshairplay.raop_stop.argtypes = [c_void_p]
  67         libshairplay.raop_destroy.restype = None
  68         libshairplay.raop_destroy.argtypes = [c_void_p]
  69
  70 def LoadShairplay(path):
  71         if sys.maxsize < 2**32:
  72                 libname = "shairplay32"
  73         else:
  74                 libname = "shairplay64"
  75
  76         if platform.system() == "Windows":
  77                 libname = libname + ".dll"
  78         elif platform.system() == "Darwin":
  79                 libname = "lib" + libname + ".dylib"
  80         else:
  81                 libname = "lib" + libname + ".so"
  82
  83         try:
  84                 fullpath = os.path.join(path, libname)
  85                 libshairplay = cdll.LoadLibrary(fullpath)
  86         except:
  87                 raise RuntimeError("Couldn't load shairplay library " + libname)
  88
  89         InitShairplay(libshairplay)
  90         return libshairplay
  91
  92 RSA_KEY = """
  93 -----BEGIN RSA PRIVATE KEY-----
  94 MIIEpQIBAAKCAQEA59dE8qLieItsH1WgjrcFRKj6eUWqi+bGLOX1HL3U3GhC/j0Qg90u3sG/1CUt
  95 wC5vOYvfDmFI6oSFXi5ELabWJmT2dKHzBJKa3k9ok+8t9ucRqMd6DZHJ2YCCLlDRKSKv6kDqnw4U
  96 wPdpOMXziC/AMj3Z/lUVX1G7WSHCAWKf1zNS1eLvqr+boEjXuBOitnZ/bDzPHrTOZz0Dew0uowxf
  97 /+sG+NCK3eQJVxqcaJ/vEHKIVd2M+5qL71yJQ+87X6oV3eaYvt3zWZYD6z5vYTcrtij2VZ9Zmni/
  98 UAaHqn9JdsBWLUEpVviYnhimNVvYFZeCXg/IdTQ+x4IRdiXNv5hEewIDAQABAoIBAQDl8Axy9XfW
  99 BLmkzkEiqoSwF0PsmVrPzH9KsnwLGH+QZlvjWd8SWYGN7u1507HvhF5N3drJoVU3O14nDY4TFQAa
 100 LlJ9VM35AApXaLyY1ERrN7u9ALKd2LUwYhM7Km539O4yUFYikE2nIPscEsA5ltpxOgUGCY7b7ez5
 101 NtD6nL1ZKauw7aNXmVAvmJTcuPxWmoktF3gDJKK2wxZuNGcJE0uFQEG4Z3BrWP7yoNuSK3dii2jm
 102 lpPHr0O/KnPQtzI3eguhe0TwUem/eYSdyzMyVx/YpwkzwtYL3sR5k0o9rKQLtvLzfAqdBxBurciz
 103 aaA/L0HIgAmOit1GJA2saMxTVPNhAoGBAPfgv1oeZxgxmotiCcMXFEQEWflzhWYTsXrhUIuz5jFu
 104 a39GLS99ZEErhLdrwj8rDDViRVJ5skOp9zFvlYAHs0xh92ji1E7V/ysnKBfsMrPkk5KSKPrnjndM
 105 oPdevWnVkgJ5jxFuNgxkOLMuG9i53B4yMvDTCRiIPMQ++N2iLDaRAoGBAO9v//mU8eVkQaoANf0Z
 106 oMjW8CN4xwWA2cSEIHkd9AfFkftuv8oyLDCG3ZAf0vrhrrtkrfa7ef+AUb69DNggq4mHQAYBp7L+
 107 k5DKzJrKuO0r+R0YbY9pZD1+/g9dVt91d6LQNepUE/yY2PP5CNoFmjedpLHMOPFdVgqDzDFxU8hL
 108 AoGBANDrr7xAJbqBjHVwIzQ4To9pb4BNeqDndk5Qe7fT3+/H1njGaC0/rXE0Qb7q5ySgnsCb3DvA
 109 cJyRM9SJ7OKlGt0FMSdJD5KG0XPIpAVNwgpXXH5MDJg09KHeh0kXo+QA6viFBi21y340NonnEfdf
 110 54PX4ZGS/Xac1UK+pLkBB+zRAoGAf0AY3H3qKS2lMEI4bzEFoHeK3G895pDaK3TFBVmD7fV0Zhov
 111 17fegFPMwOII8MisYm9ZfT2Z0s5Ro3s5rkt+nvLAdfC/PYPKzTLalpGSwomSNYJcB9HNMlmhkGzc
 112 1JnLYT4iyUyx6pcZBmCd8bD0iwY/FzcgNDaUmbX9+XDvRA0CgYEAkE7pIPlE71qvfJQgoA9em0gI
 113 LAuE4Pu13aKiJnfft7hIjbK+5kyb3TysZvoyDnb3HOKvInK7vXbKuU4ISgxB2bB3HcYzQMGsz1qJ
 114 2gG0N5hvJpzwwhbhXqFKA4zaaSrw622wDniAK5MlIE0tIAKKP4yxNGjoD2QYjhBGuhvkWKY=
 115 -----END RSA PRIVATE KEY-----
 116 """
 117
 118 class RaopCallbacks:
 119         def audio_init(self, bits, channels, samplerate):
 120                 raise NotImplementedError()
 121
 122         def audio_set_volume(self, session, volume):
 123                 pass
 124
 125         def audio_process(self, session, buffer):
 126                 raise NotImplementedError()
 127
 128         def audio_flush(self, session):
 129                 pass
 130
 131         def audio_destroy(self, session):
 132                 pass
 133
 134 class RaopService:
 135         def audio_init_cb(self, cls, bits, channels, samplerate):
 136                 session = self.callbacks.audio_init(bits, channels, samplerate)
 137                 self.sessions.append(session)
 138                 return session
 139
 140         def audio_set_volume_cb(self, cls, sessionptr, volume):
 141                 session = cast(sessionptr, py_object).value
 142                 self.callbacks.audio_set_volume(session, volume)
 143
 144         def audio_process_cb(self, cls, sessionptr, buffer, buflen):
 145                 session = cast(sessionptr, py_object).value
 146                 strbuffer = string_at(buffer, buflen)
 147                 self.callbacks.audio_process(session, strbuffer)
 148
 149         def audio_flush_cb(self, cls, sessionptr):
 150                 session = cast(sessionptr, py_object).value
 151                 self.callbacks.audio_flush(session)
 152
 153         def audio_destroy_cb(self, cls, sessionptr):
 154                 session = cast(sessionptr, py_object).value
 155                 self.callbacks.audio_destroy(session)
 156                 if session in self.sessions:
 157                         self.sessions.remove(session)
 158
 159
 160         def __init__(self, libshairplay, callbacks):
 161                 self.libshairplay = libshairplay
 162                 self.callbacks = callbacks
 163                 self.sessions = []
 164                 self.instance = None
 165
 166                 # We need to hold a reference to native_callbacks
 167                 self.native_callbacks = RaopNativeCallbacks()
 168                 self.native_callbacks.audio_init = audio_init_prototype(self.audio_init_cb)
 169                 self.native_callbacks.audio_set_volume = audio_set_volume_prototype(self.audio_set_volume_cb)
 170                 self.native_callbacks.audio_process = audio_process_prototype(self.audio_process_cb)
 171                 self.native_callbacks.audio_flush = audio_flush_prototype(self.audio_flush_cb)
 172                 self.native_callbacks.audio_destroy = audio_destroy_prototype(self.audio_destroy_cb)
 173
 174                 # Initialize the raop instance with our callbacks
 175                 self.instance = self.libshairplay.raop_init(pointer(self.native_callbacks), RSA_KEY)
 176                 if self.instance == None:
 177                         raise RuntimeError("Initializing library failed")
 178
 179         def __del__(self):
 180                 if self.instance != None:
 181                         self.libshairplay.raop_destroy(self.instance)
 182                 self.instance = None
 183
 184         def start(self, port, hwaddrstr, password=None):
 185                 port = c_ushort(port)
 186                 hwaddr = create_string_buffer(hwaddrstr, len(hwaddrstr))
 187
 188                 ret = self.libshairplay.raop_start(self.instance, pointer(port), hwaddr, c_int(len(hwaddr)), password)
 189                 if ret < 0:
 190                         raise RuntimeError("Starting RAOP instance failed")
 191                 return port.value
 192
 193         def stop(self):
 194                 self.libshairplay.raop_stop(self.instance)
 195
 196 class DnssdService:
 197         def __init__(self, libshairplay):
 198                 self.libshairplay = libshairplay
 199                 self.instance = None
 200
 201                 error = c_int(0)
 202
 203                 self.instance = self.libshairplay.dnssd_init(pointer(error))
 204                 if self.instance == None:
 205                         raise RuntimeError("Initializing library failed: " + str(error.value))
 206
 207         def __del__(self):
 208                 if self.instance != None:
 209                         self.libshairplay.dnssd_destroy(self.instance)
 210                 self.instance = None
 211
 212         def register_raop(self, name, port, hwaddrstr, password=False):
 213                 hwaddr = create_string_buffer(hwaddrstr, len(hwaddrstr))
 214                 use_pw = c_int(0)
 215                 if password:
 216                         use_pw = c_int(1)
 217                 self.libshairplay.dnssd_register_raop(self.instance, name, c_ushort(port), hwaddr, len(hwaddr), use_pw)
 218
 219         def unregister_raop(self):
 220                 self.libshairplay.dnssd_unregister_raop(self.instance)
 221
 222         def register_airplay(self, name, port, hwaddrstr):
 223                 hwaddr = create_string_buffer(hwaddrstr, len(hwaddrstr))
 224                 self.libshairplay.dnssd_register_airplay(self.instance, name, c_ushort(port), hwaddr, len(hwaddr))
 225
 226         def unregister_airplay(self):
 227                 self.libshairplay.dnssd_unregister_airplay(self.instance)
 228