Move stuff around; fix rendering

- Now actually able to render shows
- Maybe able to render chasers
- Add untested OLA lighting output
- General fixes

1 files changed, 0 insertions, 1007 deletions

diff --git a/workspace.py b/workspace.py
deleted file mode 100755
index c9f9a35..0000000
--- a/workspace.py
+++ /dev/null
@@ -1,1007 +0,0 @@
-#!/usr/bin/env python3
-
-"""Module for parsing and rendering QLC workspaces.
-
-Note that all instances of all classes in this module should be considered immutable unless 
-otherwise stated: this program is designed for reading QLC workspaces only, not modifying them.
-Additionally, no Function should be modified after creation: many properties are set at 
-creation time and will not be updated.
-
-# Differences from QLC+
-
-1. Fade timimg: there might be a 1-2ms difference in the fade lengths between this program and 
-   QLC+. If this is a problem, I would recommend also swapping out all human eyeballs and 
-   creating a protocol that isn't DMX.
-
-2. Restrictions: certain pointless things are disallowed by this program that are allowed by
-   QLC+ (though they usually crash it): circular references (e.g. chaser A includes chaser B 
-   which itself includes chaser A...), infinite length shows (this one does crash QLC+).
-
-3. Sequences: there are no sequences in this program, only chasers. To create a sequence by
-   hand, create a new Scene for each sequence step, attach it to a ChaserStep with the desired 
-   parameters, then attach the steps to a Chaser. This is automated by Workspace.load so you 
-   should never have to deal with this.
-
-4. Function overlapping: overlapping of functions on one track of a show is theoretically 
-   supported; as this isn't supported in QLC+, this is untested.
-
-5. Channel group values: channel group values are ignored. As far as I can tell, QLC+ sets the
-   value of the individual channels as well wherever channel groups are used, and I'm not sure 
-   how QLC+ determines which value takes precedence when multiple channel groups share a 
-   channel.
-
-6. Fading: this program ignores scene and sequence fade times (they seem unused) as well as the 
-   settings on chasers/sequences for step fading (QLC+ overwrites the step fade times anyways).
-   Neither of these should have any effect on output compared to QLC+.
-
-7. Sequence fading: QLC+ is just wack here. This worked as of this writing: create a show with 
-   one track and create a sequence on that track with three steps. Step 1 has 0ms fade in, 1s 
-   hold, 1s fade out and holds channel 1 at 100. Step 2 has 0ms fade in, 1s hold, 0ms fade out
-   and holds channel 2 at 100 (others at 0). Step 3 has 0ms fade in, 1s hold, 500ms fade out, 
-   and holds channel 3 at 100. According to QLC+, despite dislaying the proper values, the 
-   actual fade out times for the steps are 0ms, 500ms, and 500ms, respectively. The point is 
-   that QLC+ has no idea what to do for fade outs. This program interprets fade ins and outs as
-   identical in effect; combining them allows for somewhat non-linear fading. If you wish to 
-   replicate the QLC+ behavior, hook up a random number generator to the fading and go nuts.
-
-8. Show fading: QLC+ tends to cut fade-outs that overlap with other steps on the same track; 
-   seeing as QLC+ lacks any fade-out logic, BLC holds fades as long as they specify.
-
-9? Precedence: BLC adopts a highest-takes-precedence doctrine when determining what level lights 
-   should be held at. This may be different than QLC+.
-
-# Pre-Rendering Workspaces
-
-The typical way to render workspaces is to determine the appropriate top-level function (i.e. a 
-Show or Chaser), render that function periodically, and output the values. However, if you are 
-paranoid, certain functions can be entirely rendered ahead of time, leaving you to merely 
-dispatch the values at the appropriate time. 
-
-Any Show may be pre-rendered using Show's prerender method. This will return an iterable of the 
-form:
-    
-    [(time, values), ...]
-
-Where values is as returned by a single call to the Show's render method. The values given at a
-certain time index must be held until the next time index.
-
-A Chaser may be pre-rendered provided it satisfies:
-
-    - No infinite length fades
-    - All steps of infinite-length are Scenes
-
-Chaser's render_all method will return an iterable of iterables of the form:
-
-    [[(time, values), ...], ...]
-
-Each block of (time, values) pairs represents an infinite segment in the chaser, i.e. the final 
-value in each block should be held until some condition becomes true. This does restrict the 
-chaser in that steps of finite length cannot be skipped, so take this into account. In all but 
-the first step, values does not necessarily have a value for each channel in the show's scope;
-it gives only the changed values at that time. Note also that this only supports the rendering 
-of single-shot chasers presently. Additionally, time is reset to 0 at the start of each block.
-
-# General Notes for Implementation
-
-- When a function is fading, render always returns nx=1. The reason for this is that it would 
-  require a lot more computation to calculate a more accurate value, requiring the function to 
-  render not only the current time index but also all time indexes until the value actually 
-  changes. render_all fixes this by returning only changed values, but still renders every time 
-  index during fades. If rendering shows "live", i.e. without pre-rendering, I recommend taking 
-  nx = max(nx, m) for some m > 10 (e.g. ~16 for 60 Hz DMX), as rendering faster than the 
-  transmission rate of your connection is pointless.
-
-- This library is thread-safe except for the Function "data" objects: these objects may only be 
-  used in one thread at a time.
-
-- The hash function on each class is likely to be slow: use it to prevent running an even slower 
-  operation if a function hasn't changed; a Function's hash will be consistent as long as the 
-  workspace on disk doesn't change
-"""
-
-from abc import ABC, abstractmethod
-import json
-from multiprocessing.pool import ThreadPool
-import subprocess as subp
-import logging
-
-from lxml import etree
-
-## BEGIN Constants
-
-QLC_INFTY = 429467294
-
-CHASER = "Chaser"
-STEP = "Step"
-SCENE = "Scene"
-SHOW = "Show"
-SEQUENCE = "Sequence"
-AUDIO = "Audio"
-
-FORWARD = "Forward"
-LOOP = "Loop"
-SINGLESHOT = "SingleShot"
-
-QXW = "{http://www.qlcplus.org/Workspace}"
-
-## END Constants
-
-## BEGIN Utility functions
-
-def ffprobe_audio_length(f, path="ffprobe"):
-    """Use ffprobe to check audio length in milliseconds.
-
-    Will always return the nearest whole millisecond greater than or equal to the duration.
-
-    Parameters:
-        f: the path to check
-        path: the path of ffprobe
-    """
-    try:
-        a = subp.check_output([path, "-show_format", "-print_format", "json", f], stderr=subp.DEVNULL)
-    except subp.CalledProcessError:
-        return 0
-    return int(1000*float(json.loads(a)["format"]["duration"])+0.5)
-
-## END Utility functions
-
-## BEGIN Topology classes
-class Fixture:
-    """Class representing a single light fixture.
-
-    May be composed of multiple channels.
-    """
-    def __hash__(self):
-        return self._hash
-                     
-    def __repr__(self):
-        return "Fixture(id=%d, name=%s, universe=%d, start=%d, channels=%d)" % (self.id, self.name, self.universe.id, self.address_start, self.channel_count)
-
-    def __init__(self, id_, name, address, universe, mode, channels=1):
-        self.name = name
-        self.address_start = address
-        self.channel_count = channels
-        self.mode = mode
-        self.universe = universe
-        self.id = id_
-        self._hash = hash((self.name, self.address_start, self.channel_count, self.mode, 
-                           self.id, self.universe))
-        self.channels = [Channel(self, i) for i in range(channels)]
-
-class Channel:
-    """Class representing a single output channel."""
-    def __hash__(self):
-        return self._hash
-                     
-    def __repr__(self):
-        return "Channel(address=%d)" % (self.address)
-
-    def __init__(self, fixture, offset):
-        if offset >= fixture.channel_count or offset < 0:
-            raise ValueError("Invalid offset")
-        self.fixture = fixture
-        self.offset = offset
-        self.address = self.fixture.address_start + offset
-        self.universe = self.fixture.universe
-        self._hash = hash((self.fixture, self.offset, self.address))
-
-class ChannelGroup:
-    """Class representing a group of output channels."""
-    def __hash__(self):
-        return self._hash
-                     
-    def __repr__(self):
-        return "ChannelGroup(id=%d, name=%s, channels=(%s))" % (self.id, self.name,
-                                                                ", ".join((repr(c) for c in self.channels)))
-
-    def __init__(self, id_, name, channels):
-        self.id = id_
-        self.name = name 
-        self.channels = tuple(channels)
-
-        self._hash = hash((self.id, self.name, self.channels))
-
-class Universe:
-    """Class representing an output universe."""
-    def __hash__(self):
-        return self._hash
-
-    def __repr__(self):
-        return "Universe(id=%d, name=%s)" % (self.id, self.name)
-
-    def __init__(self, id_, name):
-        self.id = id_
-        self.name = name
-
-        self._hash = hash((self.id, self.name))
-
-## END Toplogy classes
-
-## BEGIN Base classes
-
-class Function(ABC):
-    """Class for representing the generic attributes of a QLC function.
-
-    id is not necessarily globally unique: in most cases it will be, but it may just be unique
-    to a given parent function (e.g. two sequences can each have a different step with the same 
-    id).
-
-    duration is the "hard" duration of the function: for steps of sequences/tracks/chasers, this 
-    is the fade in time plus the hold time of the step and is the time that must elapse
-    (barring skipping) before another step can run. actual_duration is the actual duration of
-    the function; in the same setting, this would be the sum of the fade in, hold, and fade out 
-    times.
-
-    scope must be an iterable of channels representing all of the channels used by this function 
-    regardless of whether or not they are currently being used.
-
-    This class itself must be stateless: anything that requires storage of state must also 
-    require the caller to store that state.
-    """
-    repr_attr = ("id", "name",)
-    def __hash__(self):
-        return self._hash
-
-    @staticmethod
-    def get_data():
-        """Return an initial state for the function."""
-        return None
-
-    def __repr__(self):
-        buff = []
-        for c in self.repr_attr:
-            if not issubclass(type(c), str):
-                c, f = c
-                v = repr(f(getattr(self,c)))
-            else:
-                v = repr(getattr(self,c))
-            buff.append("%s=%s" % (c,v))
-
-        return "%s(%s)" % (self.__class__.__name__, ", ".join(buff))
-
-    @abstractmethod
-    def render(self, t: int, data=None):
-        """Render the function at the given time. 
-
-        Parameters:
-            t: the time index to render in milliseconds. The first time index is 0. 
-            data: the state of the function.
-
-        t must be relative to the start time of this function. data may be used to pass in 
-        state information if necessary (e.g. current step for chasers).
-
-        This function must return a 4-tuple:
-            
-            (values, audio cues, next change, data)
-
-        Where values is a tuple of (channel, value) elements, audio_cues is a tuple of 
-        (filename, aid, start time, fade in time, fade out time, fade out start) elements, aid
-        may be used to uniquely identify instances of audio cues.
-
-        next_change is the time index of the next lighting change, and data is the state data 
-        (None if unused). values must  contain a value for exactly those channels provided in 
-        scope.
-
-        In the event of an infinite amount of time until the next change, QLC_INFTY is returned. 
-        If this function is fading, 1 should be returned (the minimum time unit). If the 
-        function is done rendering, -1 should be returned.
-
-        It is not an error to call render with a time index greater than the duration of the 
-        function: ((), (), -1, None) should be returned in this case. However, the time index 
-        will always be nonnegative.
-
-        It is an error to call render with data that has been used to render a future time; this 
-        is undefined behavior.
-        """
-        return
-
-    def __init__(self, id_, type_, name, scope, hidden=False, duration=-1, actual_duration=-1):
-        self.id = id_
-        self.type = type_
-        self.name = name
-        self.hidden = hidden
-        self.duration = min(QLC_INFTY, duration)
-        self.actual_duration = min(QLC_INFTY, actual_duration)
-        self.scope = tuple(scope)
-
-        self._hash = hash((self.id, self.type, self.name, self.scope, self.hidden, self.duration,
-                           self.actual_duration))
-
-class FadeFunction(Function):
-    """QLC function that can fade in/out."""
-    def __init__(self, id_, type_, name, scope, hidden=False, duration=-1, actual_duration=-1, fade_in=0, fade_out=0):
-        if fade_in >= QLC_INFTY or fade_out >= QLC_INFTY:
-            raise ValueError("Fades cannot be infinite")
-        super().__init__(id_, type_, name, scope, hidden=hidden, duration=duration, actual_duration=actual_duration)
-        self.fade_in = min(QLC_INFTY, fade_in)
-        self.fade_out = min(QLC_INFTY, fade_out)
-
-        self._hash = hash((self._hash, self.fade_in, self.fade_out))
-
-class Advanceable(ABC):
-    """Function that may be advanced."""
-    @abstractmethod
-    def advance(self, data):
-        """Advance the function."""
-        return
-
-## END Base classes
-
-## BEGIN Function classes
-
-class Audio(FadeFunction):
-    """Class for a QLC+ audio function."""
-    repr_attr = ("id", "fname", "fade_in", "fade_out",)
-    def render(self, t, data=None):
-        """Render the audio function.
-
-        We do not seek to do anything related to audio in this library: the responsibility for 
-        mixing, fading, playing, probing, etc. the audio file is with the specific application. 
-        As such, this function only returns the relevant data for the audio function.o
-        """
-        if t > self.duration:
-            return (), (), -1, data
-
-        return (), ((0, self.id, self.fname, self.fade_in, self.fade_out, self.duration-self.fade_out),), self.duration+1-t, data
-
-    def __init__(self, id_, name, fname, fade_in, fade_out, length, run_order=SINGLESHOT, hidden=False):
-        super().__init__(id_, AUDIO, name, (), hidden=hidden, duration=length, 
-                         actual_duration=length, fade_in=fade_in, fade_out=fade_out)
-        self.fname = fname
-        self.run_order = run_order
-        self._hash = hash((self._hash, self.fname, self.run_order))
-
-class Scene(Function):
-    """Class for a QLC Scene.
-    
-    duration, fade_in, and fade_out are present in the XML but are ignored by QLC.
-
-    Scenes are mostly meaningless on their own in this context, they must be attached to a 
-    chaser/show to do anything.
-    """
-    def render(self, t, data=None):
-        """All arguments are unused."""
-        return self.values, (), QLC_INFTY, None
-
-    def __init__(self, id_, name, values, hidden=False):
-        super().__init__(id_, SCENE, name, (c for c,v in values), hidden=hidden, duration=-1, actual_duration=-1)
-        self.values = tuple(values)
-        self._hash = hash((self._hash, self.values))
-
-class ChaserStep(FadeFunction):
-    """A single step in a chaser."""
-    repr_attr = ("id", "name", "hold", "fade_in", "fade_out", ("function", lambda f: f.id))
-    class ChaserStepData:
-        """Data for the step."""
-        def __init__(self, fd, start_time, end_time):
-            self.fd = fd
-            self.start_time = start_time
-            self.end_time = end_time
-
-    def get_data(self, start_time=0):
-        return self.ChaserStepData(fd=self.function.get_data(), start_time=start_time, end_time=self.duration)
-
-    def render(self, t, data:ChaserStepData=None):
-        ## The logic is different here: we never check the actual duration of this function and 
-        ## never return -1, the responsibility for determining if this step is over lies with 
-        ## the Chaser. The return value is also different: we return (vals, mul) instead of just 
-        ## vals. mul is the "multiplier" for the function, i.e. what we think that this function
-        ## should be rendered at. If t > actual_duration, then mul will be 0 (this function is 
-        ## done), but we still need to return the values because the next step might be fading 
-        ## in and so will need to know the values of this function.
-        if data is None:
-            data = self.get_data()
-        t -= data.start_time
-        ## Render the function at time t
-        values, acues, nx, data.fd = self.function.render(t, data=data.fd)
-        ## Determine the multiplier
-        mul = 1
-        if self.fade_in > 0 and t < self.fade_in: ## Fade in first
-            mul = min(1,t/self.fade_in)
-            nx = 1
-        elif self.fade_out > 0: ## Then fade out
-            ft = t - data.end_time + 1
-            if ft > 0:
-                mul = 1-min(1,ft/(self.fade_out))
-                nx = -1 if ft > self.fade_out else 1 ## Check if we're done
-            else:
-                nx = min(nx, -ft + 1)
-        elif t >= data.end_time:
-            mul = 0
-
-        if t < data.end_time:
-            nx = min(nx, data.end_time-t)
-
-        nacues = []
-        for s, aid, f, fin, fout, fstart in acues:
-            if fstart + fout > self.fade_out + data.end_time:
-                fstart = data.end_time - self.fade_out
-                fout = self.fade_out
-            nacues.append((s+data.start_time, hash((self.id, data.start_time, aid)), 
-                           f, max(self.fade_in, fin), fout, fstart))
-
-        return (values, mul), tuple(nacues), nx, data
-
-    def __init__(self, id_, fade_in, fade_out, hold, function):
-        super().__init__(id_, STEP, function.name, function.scope, hidden=False, 
-                         duration=hold+fade_in, actual_duration=hold+fade_out+fade_in,
-                         fade_in=fade_in, fade_out=fade_out)
-        self.id = id_
-        self.hold = hold
-        self.function = function
-        self._hash = hash((self._hash, self.function, self.hold))
-
-class Chaser(Function, Advanceable):
-    """Class for representing a QLC+ Chaser or Sequence.
-
-    Since they essentially do the same thing (Chaser being more general), they have only one 
-    class here."""
-    repr_attr = ("id", "name", ("steps", lambda s: ",".join((i.id for i in s))))
-    class ChaserData:
-        """Current state of a chaser."""
-        def __init__(self, step_data, obey_loop):
-            self.step_data = step_data 
-            self.obey_loop = obey_loop 
-
-    @staticmethod
-    def advance(t, data):
-        """End the current chaser step. 
-
-        After calling this function, the chaser must be rendered at a time at least t before 
-        calling it again. 
-        """
-        if data.step_data:
-            data.step_data[-1][1].end_time = t - data.step_data[-1][1].start_time
-
-        return data
-            
-    def get_data(self):
-        return self.ChaserData(step_data=[], obey_loop=True)
-
-    def next_step(self, n) -> int: ## TODO: Implement other chaser types
-        """Return the next step in the chaser."""
-        if self.run_order == LOOP:
-            return (n+1) % len(self.steps)
-        elif self.run_order == SINGLESHOT:
-            if n >= len(self.steps) - 1:
-                return -1
-            return n+1
-        return None
-
-    def render(self, t, data=None):
-        if t >= self.actual_duration: ## Quick check
-            return (), (), -1, data
-        elif data is None:
-            data = self.get_data()
-
-        if not data.step_data:
-            data.step_data.append((0, self.steps[0].get_data()))
-
-        vals = {c: 0 for c in self.scope}
-        nx = QLC_INFTY
-        i = 0
-        acues = []
-        svs = []
-        ## First pass, get values
-        while i < len(data.step_data):
-            sn, sd = data.step_data[i]
-            step = self.steps[sn]
-            sv, sacues, snx, _ = step.render(t, sd)
-            acues.extend(sacues)
-            ## Figure out if we're fading out or in
-            svs.append((t > (sd.start_time+sd.end_time), sv))
-            if t >= sd.start_time + sd.end_time and i+1 == len(data.step_data): ## Add the next step
-                nsn = self.next_step(sn)
-                if nsn != -1: ## Still another step to do
-                    nss = sd.start_time + sd.end_time
-                    data.step_data.append((nsn, self.steps[nsn].get_data(nss)))
-            if t >= sd.start_time+sd.end_time+step.fade_out and (len(data.step_data) == i+1  or (len(data.step_data) > i+1 and t >= data.step_data[i+1][1].start_time + self.steps[data.step_data[i+1][0]].fade_in)): ## Done this step
-                data.step_data.pop(i)
-                continue
-            if snx < nx and snx != -1:
-                nx = snx
-            i += 1
-
-        ## Second pass, handle fading
-        zero = {c: 0 for c in self.scope}
-        for i, (fout, (cval,mul)) in enumerate(svs):
-            if mul == 0:
-                continue
-            cval = dict(cval)
-
-            if mul == 1: ## Don't bother looking for another one
-                other = zero
-            elif fout: ## Grab the previous step's values
-                other = zero if i+1 == len(svs) else dict(svs[i+1][1][0])
-            else: ## Grab the next step's values
-                other = zero if i == 0 else dict(svs[i-1][1][0])
-
-            for c in self.scope:
-                v = (other[c]*(1-mul) if c in other else 0) + (mul*cval[c] if c in cval else 0)
-                v = min(255, int(v+0.5))
-                if vals[c] < v:
-                    vals[c] = v
-
-        if not data.step_data:
-            return (), (), -1, data
-
-        return tuple(vals.items()), tuple(sorted(acues, key=lambda a: a[0])), nx, data
-
-    def render_all(self, minnx=1):
-        """Render the entire Chaser."""
-        ## Verify that we can render this one
-        if self.run_order != SINGLESHOT:
-            raise ValueError("Can only render SingleShot Chasers")
-        for s in self.steps:
-            if s.hold == QLC_INFTY and s.function.actual_duration == QLC_INFTY:
-                raise ValueError("Cannot render Chaser with infinite hold of infinite function")
-            elif QLC_INFTY in (s.fade_in, s.fade_out):
-                raise ValueError("Cannot render Chaser with infinite fades")
-        
-        steps = []
-
-        t = 0
-        start_time = 0
-        data = None
-        current = []
-        acurrent = []
-        
-        values = {c: 0 for c in self.scope}
-        
-        ## We're gonna have to break encapsulation here
-        while True:
-            vals, acues, nx, data = self.render(t, data=data)
-            changes = []
-            for c,v in vals:
-                if t == 0 or values[c] != v:
-                    values[c] = v
-                    changes.append((c, v))
-            current.append((t-start_time, tuple(changes)))
-
-            acurrent += [(t-start_time, *others) for t,*others in acues]
-
-            if nx == -1 or nx >= QLC_INFTY:
-                ## Done the current step
-                steps.append((tuple(current), tuple(acurrent)))
-                if nx == -1:
-                    ## Done
-                    break
-                ## Reached an infinite segment, advance
-                current = []
-                acurrent = []
-                t += 1
-                start_time = t
-                data = self.advance(t, data)
-            else:
-                t += max(minnx, nx)
-
-        return tuple(steps)
-
-    def __init__(self, id_, name, steps, hidden=False, run_order=SINGLESHOT, direction=FORWARD):
-        if run_order not in (LOOP, SINGLESHOT):
-            raise NotImplementedError("Only Loop and SingleShot chasers are currently supported")
-        if direction not in (FORWARD,):
-            raise NotImplementedError("Only Forward direction chasers are currently supported")
-        scope = set()
-        if run_order == SINGLESHOT:
-            max_t = 0
-            cur = 0
-            for s in steps:
-                max_t = max(max_t, cur+s.actual_duration)
-                scope.update(s.scope)
-                cur += s.duration
-            dur = sum(map(lambda s: s.duration, steps))
-        elif run_order == LOOP:
-            for s in steps:
-                scope.update(s.scope)
-            max_t = QLC_INFTY
-            dur = QLC_INFTY
-        super().__init__(id_, CHASER, name, scope, hidden=hidden, 
-                         duration=dur, actual_duration=max_t)
-        self.steps = tuple(steps)
-        self.run_order = run_order
-        self.direction = direction
-        self._hash = hash((self._hash, self.steps, self.run_order, self.direction))
-
-class ShowFunction(Function):
-    """Class for representing a function in a show."""
-    repr_attr = ("id", "name", "start_time", ("function", lambda f: f.id))
-    def render(self, t, data=None):
-        if data is None:
-            data = self.function.get_data()
-        
-        values, acues, nx, data = self.function.render(t-self.start_time, data=data)
-        return values, tuple(((at+self.start_time,hash((self.id, self.start_time, aid)),
-                               *others) for at,aid,*others in acues)), nx, data
-
-    def __init__(self, id_, name, function, start_time):
-        if function.actual_duration >= QLC_INFTY:
-            raise ValueError("Cannot have infinite-length functions in shows")
-        super().__init__(id_, "ShowFunction", name, function.scope, duration=function.duration,
-                         actual_duration=function.actual_duration)
-        self.function = function
-        self.start_time = start_time
-        self._hash = hash((self._hash, self.start_time, self.function))
-
-class ShowTrack(Function):
-    """Class for representing a track in a show."""
-    repr_attr = ("id", "name", ("functions", lambda fs: ','.join(("%d@%d" % (f.function.id, f.start_time) for f in fs))))
-    def get_data(self):
-        return tuple((f.function.get_data() for f in self.functions))
-
-    def render(self, t, data=None):
-        if t > self.actual_duration:
-            return (), (), -1, data
-
-        if data is None:
-            data = self.get_data()
-
-        values = {c: 0 for c in self.scope}
-        acues = []
-        nx = QLC_INFTY
-        for f,d in zip(self.functions,data):
-            if t < f.start_time or t > f.start_time + f.actual_duration:
-                continue
-            vals, sacues, snx, _ = f.render(t, data=d)
-            acues.extend(sacues)
-            for c, v in vals:
-                if v > values[c]:
-                    values[c] = v
-            if snx < 0:
-                continue
-            elif snx < nx:
-                nx = snx
-        if nx == QLC_INFTY:
-            nx = min((f.start_time-t for f in self.functions if f.start_time > t), default=-1)
-
-        return tuple(values.items()), tuple(sorted(acues, key=lambda a: a[0])), nx, data
-
-    def __init__(self, id_, name, functions):
-        dur = -1
-        adur = -1
-        self.functions = tuple(sorted(functions, key=lambda f: f.start_time))
-        scope = set()
-        for f in self.functions:
-            if f.start_time + f.actual_duration > adur:
-                adur = f.start_time + f.actual_duration
-            if f.start_time + f.duration > dur:
-                dur = f.start_time + f.duration
-            scope.update(f.scope)
-        super().__init__(id_, "ShowTrack", name, scope, duration=dur, actual_duration=adur)
-        self._hash = hash((self._hash, self.functions))
-
-class Show(Function):
-    """Class representing a QLC+ show."""
-    def render(self, t, data=None):
-        if t > self.actual_duration:
-            return (), (), -1, data
-
-        if data is None:
-            data = tuple((t.get_data() for t in self.tracks))
-
-        values = {c: 0 for c in self.scope}
-        nx = QLC_INFTY
-        acues = []
-        for track,d in zip(self.tracks,data):
-            if t > track.actual_duration:
-                continue
-            vals, tacues, tnx, _ = track.render(t, data=d)
-            acues.extend(tacues)
-            if tnx == -1:
-                continue
-            for c,v in vals:
-                if values[c] < v:
-                    values[c] = v
-            if tnx < nx:
-                nx = tnx
-        
-        return tuple(values.items()), tuple(sorted(acues, key=lambda a: a[0])), nx, data
-
-    def render_all(self, minnx=1):
-        """Render the entire show.
-        
-        minnx is the minimum amount of time between render steps. Setting this to a few 
-        milliseconds less than the transmission time of your connection should be fine, but 
-        the default value of 1 ensures that every fade is rendered as perfectly as it can be 
-        when using integer milliseconds. The time-complexity of this function is approximately 
-        linear in minnx (e.g. minnx=10 will be around 10 times faster than minnx=1 for the same 
-        show).
-
-        This function returns:
-
-            cues, audio_cues
-
-        Where cues is of the form:
-
-            [(time, ((channel, value), (channel, value), ...)), ...]
-
-        Note that (channel, value) pairs are only present if that channel changed value at the 
-        given t value, so values must be held at previous levels if they are ommitted. 
-
-        audio_cues is of the form:
-
-            [(start time, filename, fade in, fade out, fade out start time), ...]
-
-        Both cues and audio_cues are sorted by t/start time. A typical loop for rendering 
-        lighting cues would be:
-
-            cues, _ = show.render_all()
-            current_time = 0
-
-            while cues:
-                while cues[0][0] < current_time:
-                    _, changes = cues.pop(0)
-                    for c, v in changes:
-                        ## Set address c to value v
-        """
-        if self.actual_duration == QLC_INFTY:
-            raise ValueError("Cannot render infinite-length shows (please rethink your life if you created this show)")
-
-        acues = set()
-        cues = []
-        t = 0
-        current = {c: 0 for c in self.scope}
-        data = None
-        while True:
-            changes = []
-            vals, tacues, nx, data = self.render(t, data=data)
-            for c,v in vals:
-                if t == 0 or current[c] != v:
-                    changes.append((c.address, v))
-                    current[c] = v
-            if changes:
-                cues.append((t,tuple(changes)))
-            acues.update(tacues)
-            if nx < 0:
-                break
-            t += max(nx, minnx)
-
-        return tuple(cues), tuple(sorted(acues, key=lambda a: a[1]))
-
-    def __init__(self, id_, name, tracks):
-        scope = set()
-        dur = -1
-        adur = -1
-        for t in tracks:
-            scope.update(t.scope)
-            if t.duration > dur:
-                dur = t.duration
-            if t.actual_duration > adur:
-                adur = t.actual_duration
-        super().__init__(id_, SHOW, name, scope, duration=dur, actual_duration=adur)
-        self.tracks = tuple(tracks)
-        self._hash = hash((self._hash, self.tracks))
-
-## END Function classes
-
-## BEGIN Primary classes
-
-class Workspace:
-    """Class for representing a QLC workspace.
-
-    Should be created using Workspace.load and is assumed to be immutable.
-    """
-    @classmethod
-    def load(cls, fname, audio_length=ffprobe_audio_length):
-        """Load a QLC+ workspace.
-
-        This function returns the created Workspace object. 
-
-        Parameters:
-            fname: the file to load from. May be any format accepted by lxml.etree.parse. 
-            audio_length: a function accepting an audio filename and returning the length of
-                          that audio file in milliseconds.
-        """
-        a = etree.parse(fname)
-        ws = a.getroot()
-    
-        creator = ws.find(QXW+"Creator")
-        self = cls(creator.find(QXW+"Name").text, creator.find(QXW+"Version").text,
-                   creator.find(QXW+"Author").text)
-
-        engine = ws.find(QXW+"Engine")
-
-        ## Load universes
-        logging.info("Loading universes...")
-        for u in engine.find(QXW+"InputOutputMap").findall(QXW+"Universe"):
-            uid = int(u.attrib["ID"])
-            self.universes[uid] = Universe(uid, u.attrib["Name"])
-        logging.info("Loaded %d universe(s)" % len(self.universes))
-
-        ## Load fixtures
-        logging.info("Loading fixtures...")
-        total_channels = 0
-        for f in engine.iterfind(QXW+"Fixture"):
-            fid = int(f.find(QXW+"ID").text)
-            uid = int(f.find(QXW+"Universe").text)
-            name = f.find(QXW+"Name").text
-            address = int(f.find(QXW+"Address").text) + 1 ## TODO: +1, yes or no?
-            channels = int(f.find(QXW+"Channels").text)
-            total_channels += channels
-            mode = f.find(QXW+"Mode")
-            self.fixtures[fid] = Fixture(fid, name, address, self.universes[uid], mode, channels=channels)
-        logging.info("Loaded %d fixtures with %d channels" % (len(self.fixtures), total_channels))
-
-        ## Load channel groups
-        logging.info("Loading channel groups...")
-        for cg in engine.iterfind(QXW+"ChannelsGroup"):
-            vals = [int(i) for i in cg.text.split(',')]
-            cg = ChannelGroup(int(cg.attrib["ID"]), cg.attrib["Name"], 
-                              [self.fixtures[fid].channels[offset] for fid, offset in zip(vals[::2], vals[1::2])])
-            self.channel_groups[cg.id] = cg
-        logging.info("Loaded %d channel groups" % len(self.channel_groups))
-                               
-        logging.info("Determining proper function load order...")
-        load = []
-        audio_fnames = []
-        ids = set()
-        work = engine.iterfind(QXW+"Function")
-        while work:
-            todo = []
-            for f in work:
-                typ = f.attrib["Type"]
-                bad = False
-                if typ == SHOW:
-                    for t in f.iterfind(QXW+"Track"):
-                        for s in t.iterfind(QXW+"ShowFunction"):
-                            if s.attrib["ID"] not in ids:
-                                bad = True 
-                                break
-                        if bad:
-                            break
-                elif typ == CHASER:
-                    for s in f.iterfind(QXW+"Step"):
-                        if s.text not in ids:
-                            bad = True
-                            break
-                elif typ == AUDIO:
-                    audio_fnames.append(f.find(QXW+"Source").text)
-                if bad:
-                    todo.append(f)
-                else:
-                    ids.add(f.attrib["ID"])
-                    load.append(f)
-            work = todo
-        logging.info("Found %d functions" % len(load))
-
-        ## Calculate all audio lengths before load. This will reduce duplicate calls if the same 
-        ## file is present in multiple functions and lets us use a ThreadPool to speed it up
-        logging.info("Scanning %d audio functions..." % len(audio_fnames))
-        with ThreadPool() as pool:
-            audio_fnames = tuple(set(audio_fnames))
-            audio_lengths = {f: l for f,l in zip(audio_fnames, pool.map(audio_length, audio_fnames))}
-        
-        if 0 in audio_lengths.values():
-            for f,l in audio_lengths.items():
-                if l == 0:
-                    logging.warning("zero-length audio file \"%s\"" % f)
-
-        logging.info("Scanned %d audio functions" % len(load))
-
-        ## Now have an appropriate load order, load them
-        logging.info("Loading functions...")
-        for func in load:
-            ftype = func.attrib["Type"]
-            sid = int(func.attrib["ID"])
-            speed = func.find(QXW+"Speed")
-            if speed is not None:
-                fin = int(speed.attrib["FadeIn"])
-                fout = int(speed.attrib["FadeOut"])
-            else:
-                fin = None
-                fout = None
-            hidden = ("Hidden" in func.attrib) and (func.attrib["Hidden"] == "True")
-            name = func.attrib["Name"]
-            ro = func.find(QXW+"RunOrder")
-            if ro is not None:
-                ro = ro.text
-            
-            if ftype == SCENE: ## Scenes can't depend on other scenes, do them first
-                values = []
-                for v in func.iterfind(QXW+"FixtureVal"):
-                    if v.text is None:
-                        vals = (0, 0)
-                    else:
-                        vals = [int(i) for i in v.text.split(',')]
-                    fixture = self.fixtures[int(v.attrib["ID"])]
-                    for offset, val in zip(vals[::2], vals[1::2]):
-                        values.append((fixture.channels[offset], val))
-
-                func = Scene(sid, name, values, hidden=hidden)
-            elif ftype == AUDIO:
-                fname = func.find(QXW+"Source").text
-                func = Audio(sid, name, fname, fin, fout, audio_lengths[fname], run_order=ro,
-                             hidden=hidden)
-            elif ftype == SEQUENCE:
-                ## smodes = func.find(QXW+"SpeedModes")
-                ## sfin = smodes.attrib["FadeIn"]
-                ## sfout = smodes.attrib["FadeOut"]
-                ## sdur = smodes.attrib["Duration"]
-                ## bound_scene = self.functions[int(func.attrib["BoundScene"])]
-                steps = []
-                for step in func.iterfind(QXW+"Step"):
-                    stfin = int(step.attrib["FadeIn"])
-                    stnum = int(step.attrib["Number"])
-                    stfout = int(step.attrib["FadeOut"])
-                    sthold = int(step.attrib["Hold"])
-                    used = set()
-                    values = []
-                    if step.text is not None:
-                        conv = step.text.split(':')
-                        for fid, val in zip(conv[::2], conv[1::2]):
-                            fixture = self.fixtures[int(fid)]
-                            offset, value = val.split(',')
-                            channel = fixture.channels[int(offset)]
-                            used.add(channel)
-                            values.append((channel, int(value)))
-                    ## for c,_ in bound_scene.values:
-                    ##     if c not in used:
-                    ##         values.append((c, 0))
-                    scene = Scene(stnum, "", values, hidden=True)
-                    step = ChaserStep(stnum, fade_in=stfin, fade_out=stfout, hold=sthold,
-                                      function=scene)
-                    steps.append(step)
-                func = Chaser(sid, name, steps, hidden=hidden, 
-                              run_order=func.find(QXW+"RunOrder").text,
-                              direction=func.find(QXW+"Direction").text)
-            elif ftype == SHOW: ## Finally shows
-                ## td = func.find(QXW+"TimeDivision")
-                ## tdtype = td.attrib["Type"]
-                ## tdbpm = int(td.attrib["BPM"])
-                tracks = []
-                for track in func.iterfind(QXW+"Track"):
-                    tmute = track.attrib["isMute"] == "1"
-                    if tmute:
-                        continue
-                    tid = int(track.attrib["ID"])
-                    tname = track.attrib["Name"]
-                    ## if "SceneID" in track.attrib:
-                    ##     tscene = self.functions[int(track.attrib["SceneID"])]
-                    ## else:
-                    ##     tscene = None
-                    funcs = []
-                    for sf in track.iterfind(QXW+"ShowFunction"):
-                        sfid = int(sf.attrib["ID"])
-                        sfstart = int(sf.attrib["StartTime"])
-                        funcs.append(ShowFunction(sfid, "", self.functions[sfid], sfstart))
-
-                    tracks.append(ShowTrack(tid, tname, funcs))
-                if not tracks:
-                    continue
-                func = Show(sid, name, tracks)
-            elif ftype == CHASER:
-                ## smodes = func.find(QXW+"SpeedModes")
-                ## sfin = smodes.attrib["FadeIn"]
-                ## sfout = smodes.attrib["FadeOut"]
-                ## sdur = smodes.attrib["Duration"]
-                steps = []
-                for step in func.iterfind(QXW+"Step"):
-                    stfin = int(step.attrib["FadeIn"])
-                    stnum = int(step.attrib["Number"])
-                    stfout = int(step.attrib["FadeOut"])
-                    sthold = int(step.attrib["Hold"])
-                    stid = int(step.text)
-                    step = ChaserStep(stid, stfin, stfout, sthold, self.functions[stid])
-                    steps.append(step)
-                func = Chaser(sid, name, steps, hidden=hidden, 
-                              run_order=func.find(QXW+"RunOrder").text,
-                              direction=func.find(QXW+"Direction").text)
-            else:
-                raise ValueError("Unhandled type %s" % ftype)
-
-            self.functions[sid] = func
-        
-        logging.info("Loaded %d top-level functions" % len(self.functions))
-
-        return self
-
-    def __init__(self, creator, version, author):
-        self.universes = {}
-        self.fixtures = {}
-        self.channel_groups = {}
-        self.creator = creator
-        self.version = version
-        self.author = author
-        self.functions = {}
-    
-## END Primary classes