|
from typing import Dict |
|
import torch |
|
from ddsp.core import tf_float32 |
|
import tensorflow as tf |
|
import ddsp |
|
import numpy as np |
|
from torch import tensor |
|
from melody_synth.complex_torch_synth import SinSawSynth, DoubleSawSynth, TriangleSawSynth, SinTriangleSynth |
|
from torchsynth.config import SynthConfig |
|
|
|
if torch.cuda.is_available(): |
|
device = "cuda" |
|
else: |
|
device = "cpu" |
|
|
|
|
|
class MelodyGenerator: |
|
"""This is the only external interface of the melody_synth package.""" |
|
|
|
def __init__(self, |
|
sample_rate: int, |
|
n_note_samples: int, |
|
n_melody_samples: int): |
|
self.sample_rate = sample_rate |
|
self.n_note_samples = n_note_samples |
|
self.n_melody_samples = n_melody_samples |
|
synthconfig = SynthConfig( |
|
batch_size=1, reproducible=False, sample_rate=sample_rate, |
|
buffer_size_seconds=np.float64(n_note_samples) / np.float64(sample_rate) |
|
) |
|
self.Saw_Square_Voice = DoubleSawSynth(synthconfig) |
|
self.SinSawVoice = SinSawSynth(synthconfig) |
|
self.SinTriVoice = SinTriangleSynth(synthconfig) |
|
self.TriSawVoice = TriangleSawSynth(synthconfig) |
|
|
|
def get_melody(self, params: Dict[str, float], midi) -> [tf.Tensor]: |
|
"""Generates a random melody audio. |
|
|
|
Parameters |
|
---------- |
|
params: Dict[str, float] |
|
Dictionary of specifications (see Readme). |
|
midi: List[float, float, float] |
|
Melody midi (see Readme). |
|
|
|
Returns |
|
------- |
|
onsets: List[tf.Tensor] |
|
Audio. |
|
""" |
|
|
|
osc1_amp = np.float(params.get("osc1_amp", 0)) |
|
osc2_amp = np.float(params.get("osc2_amp", 0)) |
|
attack = np.float(params.get("attack", 0)) |
|
decay = np.float(params.get("decay", 0)) |
|
sustain = np.float(params.get("sustain", 0)) |
|
release = np.float(params.get("release", 0)) |
|
cutoff_freq = params.get("cutoff_freq", 4000) |
|
|
|
syn_parameters = { |
|
("adsr", "attack"): tensor([attack]), |
|
("adsr", "decay"): tensor([decay]), |
|
("adsr", "sustain"): tensor([sustain]), |
|
("adsr", "release"): tensor([release]), |
|
("adsr", "alpha"): tensor([3]), |
|
|
|
|
|
("mixer", "vco_1"): tensor([osc1_amp]), |
|
("mixer", "vco_2"): tensor([osc2_amp]), |
|
|
|
|
|
("vco_1", "mod_depth"): tensor([0.0]), |
|
("vco_1", "tuning"): tensor([0.0]), |
|
("vco_2", "mod_depth"): tensor([0.0]), |
|
("vco_2", "tuning"): tensor([0.0]), |
|
} |
|
|
|
osc_types = params.get("osc_types", 0) |
|
if osc_types == 0: |
|
synth = self.SinSawVoice |
|
syn_parameters[("vco_2", "shape")] = tensor([1]) |
|
elif osc_types == 1: |
|
synth = self.SinSawVoice |
|
syn_parameters[("vco_2", "shape")] = tensor([0]) |
|
elif osc_types == 2: |
|
synth = self.Saw_Square_Voice |
|
syn_parameters[("vco_1", "shape")] = tensor([1]) |
|
syn_parameters[("vco_2", "shape")] = tensor([0]) |
|
elif osc_types == 3: |
|
synth = self.SinTriVoice |
|
elif osc_types == 4: |
|
synth = self.TriSawVoice |
|
syn_parameters[("vco_2", "shape")] = tensor([1]) |
|
else: |
|
synth = self.TriSawVoice |
|
syn_parameters[("vco_2", "shape")] = tensor([0]) |
|
|
|
track = np.zeros(self.n_melody_samples) |
|
for i in range(len(midi)): |
|
(location, pitch, duration) = midi[i] |
|
syn_parameters[("keyboard", "midi_f0")] = tensor([pitch]) |
|
syn_parameters[("keyboard", "duration")] = tensor([duration]) |
|
synth.set_parameters(syn_parameters) |
|
|
|
audio_out, parameters, is_train = synth() |
|
single_note = audio_out[0] |
|
|
|
single_note = np.hstack( |
|
[np.zeros(int(location * self.sample_rate)), single_note, np.zeros(self.n_melody_samples)])[ |
|
:self.n_melody_samples] |
|
track = track + single_note |
|
|
|
no_cutoff = False |
|
if no_cutoff: |
|
return track |
|
cutoff_freq = tf_float32(cutoff_freq) |
|
impulse_response = ddsp.core.sinc_impulse_response(cutoff_freq, |
|
2048, |
|
self.sample_rate) |
|
track = tf_float32(track) |
|
return ddsp.core.fft_convolve(track[tf.newaxis, :], impulse_response)[0, :] |
|
|