player.py

from Queue import PriorityQueue, Queue, Full

import numpy as np

from dspy.generator import Generator
from dspy.lib import rechannel, t2f


class Player(Generator):
    def __init__(self, sequence=[], channels=2, live=True, loop=False, clip=True, max_size=0):
        Generator.__init__(self)
        self.max_size = max_size
        self._generators = PriorityQueue(max_size)
        self._finished = Queue()
        self._gain = 0.1
        self._live = live
        self._length_cache = max([f+g.length() for (f, g) in sequence] + [0])
        self.loop = loop
        self.clip = clip
        self.num_channels = channels

        self.num_gens = 0

        if sequence:
            for (f, g) in sequence:
                self._append_gen(f, g)

        if live:
            assert(not loop)


        self.auto_reset = loop

    def _append_gen(self, frame, gen):
        try:
            self._generators.put((t2f(frame), gen), False)
        except Full:
            print('Too many generators to append another')
            return

    def add(self, gen, time=None):
        if time is None:
            frame = self.frame
        else:
            frame = t2f(time)
        self._length_cache = max(self._length_cache, gen.length() + frame)

        if self.num_gens < self.max_size or self.max_size == 0:
            self.num_gens += 1
            self._append_gen(frame, gen)

    def _reset(self):
        if self._live:
            raise Exception('Cannot reset if Player is live')

        sequence = []
        while not self._finished.empty():
            frame, gen = self._finished.get()
            gen.reset()
            sequence.append((frame, gen))

        while not self._generators.empty():
            frame, gen = self._generators.get()
            gen.reset()
            sequence.append((frame, gen))

        for frame, gen in sequence:
            self._append_gen(frame, gen)

    def _length(self):
        if self._live:
            return float('inf')

        return self._length_cache

    @property
    def gain(self):
        return self._gain

    @gain.setter
    def gain(self, value):
        self._gain = np.clip(value, 0, 1)

    def _generate(self, frame_count):
        output = np.zeros(frame_count * self.num_channels, dtype=np.float32)
        not_done = []
        while not self._generators.empty():
            frame, gen = self._generators.get()
            if frame > self.frame + frame_count:
                not_done.append((frame, gen))
                break

            delay = 0
            if frame > self.frame:
                delay = frame - self.frame

            signal, continue_flag = gen.generate(frame_count - delay)
            signal = rechannel(signal, gen.num_channels, self.num_channels)
            output[delay * self.num_channels:] += signal
            if continue_flag:
                not_done.append((frame, gen))
            else:
                if not self._live:
                    self._finished.put((frame, gen))
                self.num_gens -= 1

        for frame, gen in not_done:
            self._append_gen(frame, gen)

        output *= self.gain
        if self.clip:
            output = np.clip(output, -1, 1)
        return output