File size: 5,310 Bytes
d1d6816 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
from typing import Optional
import torch
from torch import Tensor, tensor
from torchsynth.config import SynthConfig
from torchsynth.module import (
VCO, LFO, ModulationMixer,
)
from torchsynth.signal import Signal
from torchsynth.synth import AbstractSynth
class SinLFO(LFO):
"""A LFO that generates the sine waveform.
(The implementation of this class is a modification of the code in TorchSynth) """
def output(self, mod_signal: Optional[Signal] = None) -> Signal:
# This module accepts signals at control rate!
if mod_signal is not None:
assert mod_signal.shape == (self.batch_size, self.control_buffer_size)
frequency = self.make_control(mod_signal)
argument = torch.cumsum(2 * torch.pi * frequency / self.control_rate, dim=1)
argument = argument + self.p("initial_phase").unsqueeze(1)
shapes = torch.stack(self.make_lfo_shapes(argument), dim=1).as_subclass(Signal)
mode = torch.stack([self.p(lfo) for lfo in self.lfo_types], dim=1)
mode[0] = tensor([1.0, 0., 0., 0., 0.])
mode = torch.pow(mode, self.exponent)
mode = mode / torch.sum(mode, dim=1, keepdim=True)
return torch.matmul(mode.unsqueeze(1), shapes).squeeze(1).as_subclass(Signal)
class TriLFO(LFO):
"""A LFO that generates the triangle waveform.
(The implementation of this class is a modification of the code in TorchSynth) """
def output(self, mod_signal: Optional[Signal] = None) -> Signal:
# This module accepts signals at control rate!
if mod_signal is not None:
assert mod_signal.shape == (self.batch_size, self.control_buffer_size)
frequency = self.make_control(mod_signal)
argument = torch.cumsum(2 * torch.pi * frequency / self.control_rate, dim=1)
argument = argument + self.p("initial_phase").unsqueeze(1)
shapes = torch.stack(self.make_lfo_shapes(argument), dim=1).as_subclass(Signal)
mode = torch.stack([self.p(lfo) for lfo in self.lfo_types], dim=1)
mode[0] = tensor([0.5, 0.5, 0., 0., 0.])
mode = torch.pow(mode, self.exponent)
mode = mode / torch.sum(mode, dim=1, keepdim=True)
return torch.matmul(mode.unsqueeze(1), shapes).squeeze(1).as_subclass(Signal)
class SawLFO(LFO):
"""A LFO that generates the sawtooth waveform.
(The implementation of this class is a modification of the code in TorchSynth) """
def output(self, mod_signal: Optional[Signal] = None) -> Signal:
# This module accepts signals at control rate!
if mod_signal is not None:
assert mod_signal.shape == (self.batch_size, self.control_buffer_size)
frequency = self.make_control(mod_signal)
argument = torch.cumsum(2 * torch.pi * frequency / self.control_rate, dim=1)
argument = argument + self.p("initial_phase").unsqueeze(1)
shapes = torch.stack(self.make_lfo_shapes(argument), dim=1).as_subclass(Signal)
mode = torch.stack([self.p(lfo) for lfo in self.lfo_types], dim=1)
mode[0] = tensor([0.5, 0., 0.5, 0., 0.])
mode = torch.pow(mode, self.exponent)
mode = mode / torch.sum(mode, dim=1, keepdim=True)
return torch.matmul(mode.unsqueeze(1), shapes).squeeze(1).as_subclass(Signal)
class RSawLFO(LFO):
"""A LFO that generates the sawtooth waveform.
(The implementation of this class is a modification of the code in TorchSynth) """
def output(self, mod_signal: Optional[Signal] = None) -> Signal:
# This module accepts signals at control rate!
if mod_signal is not None:
assert mod_signal.shape == (self.batch_size, self.control_buffer_size)
frequency = self.make_control(mod_signal)
argument = torch.cumsum(2 * torch.pi * frequency / self.control_rate, dim=1)
argument = argument + self.p("initial_phase").unsqueeze(1)
shapes = torch.stack(self.make_lfo_shapes(argument), dim=1).as_subclass(Signal)
mode = torch.stack([self.p(lfo) for lfo in self.lfo_types], dim=1)
mode[0] = tensor([0.5, 0., 0.0, 0.5, 0.])
mode = torch.pow(mode, self.exponent)
mode = mode / torch.sum(mode, dim=1, keepdim=True)
return torch.matmul(mode.unsqueeze(1), shapes).squeeze(1).as_subclass(Signal)
class SquareLFO(LFO):
"""A LFO that generates the square waveform.
(The implementation of this class is a modification of the code in TorchSynth) """
def output(self, mod_signal: Optional[Signal] = None) -> Signal:
# This module accepts signals at control rate!
if mod_signal is not None:
assert mod_signal.shape == (self.batch_size, self.control_buffer_size)
frequency = self.make_control(mod_signal)
argument = torch.cumsum(2 * torch.pi * frequency / self.control_rate, dim=1)
argument = argument + self.p("initial_phase").unsqueeze(1)
shapes = torch.stack(self.make_lfo_shapes(argument), dim=1).as_subclass(Signal)
mode = torch.stack([self.p(lfo) for lfo in self.lfo_types], dim=1)
mode[0] = tensor([0.5, 0., 0., 0., 0.5])
mode = torch.pow(mode, self.exponent)
mode = mode / torch.sum(mode, dim=1, keepdim=True)
return torch.matmul(mode.unsqueeze(1), shapes).squeeze(1).as_subclass(Signal) |