steamcontroller-original 2.0.0__py3-none-any.whl

steamcontroller_original/__init__.py

@@ -0,0 +1,406 @@
+# Copyright (c) 2015 Stany MARCEL <stanypub@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+from enum import IntEnum
+from threading import Event, Lock, Timer
+from time import time, sleep
+from struct import pack, unpack
+from collections import namedtuple
+
+import usb1
+
+
+VENDOR_ID = 0x28de
+PRODUCT_ID = [0x1102, 0x1142, 0x1142, 0x1142, 0x1142]
+ENDPOINT =   [3, 2, 3, 4, 5]
+CONTROLIDX = [2, 1, 2, 3, 4]
+
+HPERIOD  = 0.02
+LPERIOD  = 0.5
+DURATION = 1.0
+
+STEAM_CONTROLLER_FORMAT = [
+    ('x',   'ukn_00'),
+    ('x',   'ukn_01'),
+    ('B',   'status'),
+    ('x',   'ukn_02'),
+    ('H',   'seq'),
+    ('x',   'ukn_03'),
+    ('I',   'buttons'),
+    ('B',   'ltrig'),
+    ('B',   'rtrig'),
+    ('x',   'ukn_04'),
+    ('x',   'ukn_05'),
+    ('x',   'ukn_06'),
+    ('h',   'lpad_x'),
+    ('h',   'lpad_y'),
+    ('h',   'rpad_x'),
+    ('h',   'rpad_y'),
+    ('10x', 'ukn_07'),
+    ('h',   'gpitch'),
+    ('h',   'groll'),
+    ('h',   'gyaw'),
+    ('h',   'q1'),
+    ('h',   'q2'),
+    ('h',   'q3'),
+    ('h',   'q4'),
+    ('16x', 'ukn_08'),
+]
+
+_FORMATS, _NAMES = zip(*STEAM_CONTROLLER_FORMAT)
+
+EXITCMD = pack('>' + 'I' * 2,
+               0x9f046f66,
+               0x66210000)
+
+SteamControllerInput = namedtuple('SteamControllerInput', ' '.join([x for x in _NAMES if not x.startswith('ukn_')]))
+
+SCI_NULL = SteamControllerInput._make(unpack('<' + ''.join(_FORMATS), b'\x00' * 64))
+
+
+class SCStatus(IntEnum):
+    INPUT = 0x01
+    HOTPLUG = 0x03
+    IDLE = 0x04
+
+
+class SCButtons(IntEnum):
+    RPADTOUCH = 0b00010000000000000000000000000000
+    LPADTOUCH = 0b00001000000000000000000000000000
+    RPAD      = 0b00000100000000000000000000000000
+    LPAD      = 0b00000010000000000000000000000000  # Same for stick but without LPadTouch
+    RGRIP     = 0b00000001000000000000000000000000
+    LGRIP     = 0b00000000100000000000000000000000
+    START     = 0b00000000010000000000000000000000
+    STEAM     = 0b00000000001000000000000000000000
+    BACK      = 0b00000000000100000000000000000000
+    A         = 0b00000000000000001000000000000000
+    X         = 0b00000000000000000100000000000000
+    B         = 0b00000000000000000010000000000000
+    Y         = 0b00000000000000000001000000000000
+    LB        = 0b00000000000000000000100000000000
+    RB        = 0b00000000000000000000010000000000
+    LT        = 0b00000000000000000000001000000000
+    RT        = 0b00000000000000000000000100000000
+
+
+class HapticPos(IntEnum):
+    """Specify which pad or trig is used"""
+    RIGHT = 0
+    LEFT = 1
+
+
+class SteamController(object):
+
+    def __init__(self, callback, callback_args=None, keep_alive=False):
+        """
+        Constructor
+
+        callback: function called on usb message must take at lead a
+        SteamControllerInput as first argument
+
+        callback_args: Optional arguments passed to the callback afer the
+        SteamControllerInput argument
+        """
+        self._handle = None
+        self._number = None
+        self._ccidx = None
+        self._timer = None
+        self._timer_stop = Event()
+        self._cb_lock = Lock()
+        self._cb = callback
+        self._cb_args = callback_args
+        self._cmsg = []
+        self._ctx = usb1.USBContext()
+        self._transfer_list = []
+        self.keep_alive = keep_alive
+        try:
+            self._open()
+        except (usb1.USBError, ValueError):
+            if not keep_alive:
+                raise
+
+    def _open(self):
+        handle = []
+        pid = []
+        endpoint = []
+        ccidx = []
+        for i in range(len(PRODUCT_ID)):
+            _pid = PRODUCT_ID[i]
+            _endpoint = ENDPOINT[i]
+            _ccidx = CONTROLIDX[i]
+
+            _handle = self._ctx.openByVendorIDAndProductID(
+                VENDOR_ID, _pid,
+                skip_on_error=True,
+            )
+            if _handle is not None:
+                handle.append(_handle)
+                pid.append(_pid)
+                endpoint.append(_endpoint)
+                ccidx.append(_ccidx)
+
+        if not handle:
+            raise ValueError('No SteamController Device found')
+
+        claimed = False
+        for i in range(len(handle)):
+            self._ccidx = ccidx[i]
+            self._handle = handle[i]
+            self._pid = pid[i]
+            self._endpoint = endpoint[i]
+            dev = handle[i].getDevice()
+            cfg = dev[0]
+
+            try:
+                for inter in cfg:
+                    for setting in inter:
+                        number = setting.getNumber()
+                        if self._handle.kernelDriverActive(number):
+                            self._handle.detachKernelDriver(number)
+                        if (setting.getClass() == 3 and
+                            setting.getSubClass() == 0 and
+                            setting.getProtocol() == 0 and
+                            number == i+1):
+                            self._handle.claimInterface(number)
+                            self._number = number
+                            claimed = True
+            except usb1.USBErrorBusy:
+                claimed = False
+
+            if claimed:
+                break
+
+        if not claimed:
+            raise ValueError('All SteamController are busy')
+
+        self._transfer_list = []
+        transfer = self._handle.getTransfer()
+        transfer.setInterrupt(
+            usb1.ENDPOINT_IN | self._endpoint,
+            64,
+            callback=self._processReceivedData,
+        )
+        transfer.submit()
+        self._transfer_list.append(transfer)
+
+        self._period = LPERIOD
+
+        if self._pid == 0x1102:
+            self._timer_stop.clear()
+            self._timer = Timer(LPERIOD, self._callbackTimer)
+            # Daemonised so a timer that somehow outlives us can never
+            # keep the interpreter from exiting.
+            self._timer.daemon = True
+            self._timer.start()
+        else:
+            self._timer = None
+
+        self._tup = None
+        self._lastusb = time()
+
+        # Disable Haptic auto feedback
+
+        self._ctx.handleEvents()
+        self._sendControl(pack('>' + 'I' * 1,
+                               0x81000000))
+        self._ctx.handleEvents()
+        self._sendControl(pack('>' + 'I' * 6,
+                               0x87153284,
+                               0x03180000,
+                               0x31020008,
+                               0x07000707,
+                               0x00300000,
+                               0x2f010000))
+        self._ctx.handleEvents()
+
+    def _stopTimer(self):
+        """Stop the re-arming callback timer, if this controller has one.
+
+        Reached from __del__, which can run on an object whose __init__
+        bailed out early, so nothing here may assume an attribute exists.
+        """
+        stop = getattr(self, '_timer_stop', None)
+        if stop is not None:
+            stop.set()
+
+        timer = getattr(self, '_timer', None)
+        if timer is not None:
+            timer.cancel()
+            self._timer = None
+
+    def _close(self):
+        self._stopTimer()
+        if self._handle:
+            # _open() assigns _handle before it manages to claim an
+            # interface, so a controller that turns out to be busy leaves
+            # us holding a handle with no _number to go with it. Only
+            # talk to, and release, an interface we actually claimed;
+            # otherwise just let the handle go.
+            if self._number is not None:
+                self._sendControl(EXITCMD)
+                self._handle.releaseInterface(self._number)
+                self._number = None
+            self._handle.resetDevice()
+            self._handle.close()
+            self._handle = None
+
+    def __del__(self):
+        # A destructor must not raise, and this one runs during
+        # interpreter teardown and on half-constructed objects.
+        try:
+            self._close()
+        except Exception:
+            pass
+
+    def _sendControl(self, data, timeout=0):
+        # Control messages are a single 64-byte packet. Anything longer
+        # used to compute a negative pad length, quietly pad with
+        # nothing, and send an overlong message -- reachable from
+        # sc-test-cmsg.py, which sends whatever hex it is given.
+        if len(data) > 64:
+            raise ValueError(
+                'control message is {} bytes, maximum is 64'.format(len(data)))
+
+        zeros = b'\x00' * (64 - len(data))
+
+        self._handle.controlWrite(request_type=0x21,
+                                  request=0x09,
+                                  value=0x0300,
+                                  index=self._ccidx,
+                                  data=data + zeros,
+                                  timeout=timeout)
+
+    def addExit(self):
+        self._cmsg.insert(0, EXITCMD)
+
+    def addFeedback(self, position, amplitude=128, period=0, count=1):
+        """
+        Add haptic feedback to be sent on next usb tick
+
+        @param int position     haptic to use 1 for left 0 for right
+        @param int amplitude    signal amplitude from 0 to 65535
+        @param int period       signal period from 0 to 65535
+        @param int count        number of period to play
+        """
+        self._cmsg.insert(0, pack('<BBBHHH', 0x8f, 0x07, position, amplitude, period, count))
+
+    def _processReceivedData(self, transfer):
+        """Private USB async Rx function"""
+        if (transfer.getStatus() != usb1.TRANSFER_COMPLETED or
+            transfer.getActualLength() != 64):
+            return
+
+        data = transfer.getBuffer()
+        tup = SteamControllerInput._make(unpack('<' + ''.join(_FORMATS), data))
+        if tup.status == SCStatus.INPUT:
+            self._tup = tup
+
+        self._callback()
+
+        # Re-arm for the next packet. If the controller vanished in the
+        # meantime this raises, and it would do so from inside libusb's
+        # event handling -- escaping run() entirely and defeating the
+        # keep_alive reconnect. Leaving the transfer unsubmitted is
+        # exactly what run() watches for, so let it drive the reconnect.
+        try:
+            transfer.submit()
+        except usb1.USBError:
+            pass
+
+    def _callback(self):
+        if self._tup is None:
+            return
+
+        self._lastusb = time()
+
+        # See _callbackTimer: the wired controller drives callbacks from a
+        # Timer thread as well as from here.
+        with self._cb_lock:
+            if isinstance(self._cb_args, (list, tuple)):
+                self._cb(self, self._tup, *self._cb_args)
+            else:
+                self._cb(self, self._tup)
+
+        self._period = HPERIOD
+
+    def _callbackTimer(self):
+        # This timer re-arms itself, so without this check a closed
+        # controller would keep one alive forever -- still calling back
+        # into a mapper whose devices are gone, and leaking another
+        # thread every time the daemon reconnected.
+        if self._timer_stop.is_set():
+            return
+
+        d = time() - self._lastusb
+        self._timer.cancel()
+
+        if d > DURATION:
+            self._period = LPERIOD
+
+        self._timer = Timer(self._period, self._callbackTimer)
+        self._timer.daemon = True
+        self._timer.start()
+
+        if self._tup is None:
+            return
+
+        if d < HPERIOD:
+            return
+
+        # Serialised against the USB thread: both paths call the same
+        # user callback, and EventMapper keeps mutable state (pressed
+        # keys, smoothing deques) that two threads must not interleave.
+        with self._cb_lock:
+            if isinstance(self._cb_args, (list, tuple)):
+                self._cb(self, self._tup, *self._cb_args)
+            else:
+                self._cb(self, self._tup)
+
+    def run(self):
+        """Function to run in order to process USB events"""
+        if self._handle or self.keep_alive:
+            try:
+                while True:
+                    while any(x.isSubmitted() for x in self._transfer_list):
+                        self._ctx.handleEvents()
+                        if self._cmsg:
+                            cmsg = self._cmsg.pop()
+                            if cmsg == EXITCMD and not self.keep_alive:
+                                return
+                            self._sendControl(cmsg)
+                    try:
+                        self._close()
+                    except usb1.USBError:
+                        pass
+                    if not self.keep_alive:
+                        return
+                    sleep(2)
+                    try:
+                        self._open()
+                    except (usb1.USBError, ValueError):
+                        pass
+            except usb1.USBErrorInterrupted:
+                pass
+
+    def handleEvents(self):
+        """Function to run in order to handle USB events"""
+        if self._handle and self._ctx:
+            self._ctx.handleEvents()

steamcontroller_original/cheader.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python
+
+# The MIT License (MIT)
+#
+# Copyright (c) 2015 Stany MARCEL <stanypub@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import os
+import io
+import ast
+import sys
+import shlex
+import operator as op
+from collections import OrderedDict
+
+
+OPERATORS = {
+    ast.Add    : op.add,
+    ast.Sub    : op.sub,
+    ast.Mult   : op.mul,
+    ast.Div    : op.floordiv,
+    ast.Mod    : op.mod,
+    ast.LShift : op.lshift,
+    ast.RShift : op.rshift,
+    ast.BitOr  : op.or_,
+    ast.BitXor : op.xor,
+    ast.BitAnd : op.and_,
+    ast.Invert : op.invert,
+    ast.Not    : op.not_,
+    ast.UAdd   : op.pos,
+    ast.USub   : op.neg,
+    ast.And    : op.and_,
+    ast.Or     : op.or_,
+    ast.Eq     : op.eq,
+    ast.NotEq  : op.ne,
+    ast.Lt     : op.lt,
+    ast.LtE    : op.le,
+    ast.Gt     : op.gt,
+    ast.GtE    : op.ge,
+}
+
+
+def eval_expr(expr):
+    """Eval and expression inside a #define using a support of Python grammar"""
+    def _eval(node):
+        if isinstance(node, ast.Constant) and isinstance(node.value, int):
+            return node.value
+        if isinstance(node, ast.BinOp):
+            return OPERATORS[type(node.op)](_eval(node.left), _eval(node.right))
+        if isinstance(node, ast.UnaryOp):
+            return OPERATORS[type(node.op)](_eval(node.operand))
+        if isinstance(node, ast.BoolOp):
+            values = [_eval(x) for x in node.values]
+            return OPERATORS[type(node.op)](**values)
+        raise TypeError(node)
+
+    return _eval(ast.parse(expr, mode='eval').body)
+
+
+def read_source(filename):
+    """Read a header file into an in-memory stream for shlex.
+
+    shlex holds on to whatever stream it is handed, so passing it a live
+    file object leaks the descriptor until the garbage collector gets
+    round to it. Read the text up front and close the file immediately.
+
+    Decoding is deliberately lenient: this runs at import time (uinput.py
+    parses the kernel headers to build its Keys/Axes/Rels enums), and a
+    stray non-UTF-8 byte in a comment somewhere under /usr/include must
+    not take the whole package down.
+    """
+    with open(filename, encoding='utf-8', errors='replace') as stream:
+        return io.StringIO(stream.read())
+
+
+def defines(base, include):
+    """Extract #define from base/include following #includes"""
+    parsed = set()
+    filename = os.path.normpath(os.path.abspath(os.path.join(base, include)))
+    parsed.add(filename)
+
+    lexer = shlex.shlex(read_source(filename), posix=True)
+
+    lexer.whitespace = ' \t\r'
+    lexer.commenters = ''
+    lexer.quotes = '"'
+
+    out = OrderedDict()
+
+    def parse_c_comments(lexer, tok, ntok):
+        if tok != '/' or ntok != '*':
+            return False
+        quotes = lexer.quotes
+        lexer.quotes = ''
+        while True:
+            tok = lexer.get_token()
+            ntok = lexer.get_token()
+            if tok == '*' and ntok == '/':
+                lexer.quotes = quotes
+                break
+            lexer.push_token(ntok)
+        return True
+
+    def parse_cpp_comments(lexer, tok, ntok):
+        if tok != '/' or ntok != '/':
+            return False
+        quotes = lexer.quotes
+        lexer.quotes = ''
+        while True:
+            tok = lexer.get_token()
+            if tok == '\n':
+                lexer.quotes = quotes
+                lexer.push_token(tok)
+                break
+        return True
+
+    while True:
+        tok = lexer.get_token()
+        if not tok:
+            break
+        ntok = lexer.get_token()
+
+        if parse_c_comments(lexer, tok, ntok):
+            continue
+        if parse_cpp_comments(lexer, tok, ntok):
+            continue
+
+        if tok != '\n' or ntok != '#':
+            lexer.push_token(ntok)
+            continue
+
+        tok = lexer.get_token()
+        if tok == 'define':
+            name = lexer.get_token()
+            expr = ''
+            while True:
+                tok = lexer.get_token()
+                ntok = lexer.get_token()
+
+                if parse_c_comments(lexer, tok, ntok):
+                    continue
+                if parse_cpp_comments(lexer, tok, ntok):
+                    continue
+                lexer.push_token(ntok)
+
+                if not tok:
+                    break
+                if tok == '\n':
+                    lexer.push_token(tok)
+                    break
+
+                if tok in out:
+                    tok = str(out[tok])
+                expr = expr + tok
+
+            try:
+                val = eval_expr(expr)
+                out[name] = val
+            except (SyntaxError, TypeError):
+                pass
+        elif tok == 'include':
+            tok = lexer.get_token()
+            if tok == '<':
+                name = ''
+                while True:
+                    tok = lexer.get_token()
+                    if tok == '>':
+                        break
+                    name = name + tok
+            else:
+                name = tok
+            filename = os.path.normpath(os.path.abspath(os.path.join(base, name)))
+            if os.path.isfile(filename) and filename not in parsed:
+                parsed.add(filename)
+                lexer.push_source(read_source(filename))
+        else:
+            lexer.push_token(tok)
+
+    return out
+
+
+if __name__ == '__main__':
+    definesDict = defines(sys.argv[1], sys.argv[2])
+    for k, v in definesDict.items():
+        print('{}:\t{}'.format(k, v))