log = logging.getLogger()

registered = []

def register(f):

    registered.append(f)

    return f

@register

class Strip(object):

    """list of r,g,b tuples for sending to an LED strip"""

    which = 'L' # LR means both. W is the wide one

    pixels = []

    @classmethod

    def solid(cls, which='L', color=(1,1,1), hsv=None):

        """hsv overrides color"""

        if hsv is not None:

            color = colorsys.hsv_to_rgb(hsv[0] % 1.0, hsv[1], hsv[2])

        x = cls()

        x.which = which

        x.pixels = [tuple(color)] * 50

        return x

    def __mul__(self, f):

        if not isinstance(f, (int, float)):

from light9 import networking

from light9 import Submaster

from light9 import dmxclient

from light9 import prof

log = logging.getLogger('effectloop')

class EffectLoop(object):

    """maintains a collection of the current EffectNodes, gets time from

    music player, sends dmx"""

    def __init__(self, graph, stats):

        self.graph, self.stats = graph, stats

        self.currentSong = None

        self.lastLogTime = 0

        self.lastLogMsg = ""

        self.lastErrorLog = 0

        self.graph.addHandler(self.setEffects)

        self.period = 1 / 30

        self.coastSecs = .3 # main reason to keep this low is to notice play/pause

        self.songTimeFetch = 0

        self.songIsPlaying = False

        self.songTimeFromRequest = 0

        self.requestTime = 0 # unix sec for when we fetched songTime

        self.initOutput()

        elapsed = time.time() - t1

        reactor.callLater(max(0, self.period - elapsed), self.updateTimeFromMusic)

    def estimatedSongTime(self):

        now = time.time()

        t = self.songTime

        if self.currentPlaying:

            t += max(0, now - self.songTimeFetch)

        return t

    @inlineCallbacks

    def sendLevels(self):

        t1 = time.time()

        log.debug("time since last call: %.1f ms" % (1000 * (t1 - self.lastSendLevelsTime)))

        self.lastSendLevelsTime = t1

        try:

            with self.stats.sendLevels.time():

                if self.currentSong is not None:

                    log.debug('allEffectOutputs')

                    with self.stats.evals.time():

                        outputs = self.allEffectOutputs(self.estimatedSongTime())

                    log.debug('combineOutputs')

                    combined = self.combineOutputs(outputs)

                    self.logLevels(t1, combined)