394 lines
12 KiB
Python
394 lines
12 KiB
Python
import collections
|
|
from .exceptions import FilterInvalidArgument
|
|
|
|
|
|
class Filter:
|
|
"""
|
|
The base class for all filters.
|
|
You can use these filters if you have the latest Lavalink version
|
|
installed. If you do not have the latest Lavalink version,
|
|
these filters will not work.
|
|
|
|
You must specify a tag for each filter you put on.
|
|
This is necessary for the removal of filters.
|
|
"""
|
|
def __init__(self):
|
|
self.payload = None
|
|
self.tag: str = None
|
|
self.preload: bool = False
|
|
|
|
def set_preload(self) -> bool:
|
|
"""Internal method to set whether or not the filter was preloaded."""
|
|
self.preload = True
|
|
return self.preload
|
|
|
|
|
|
class Equalizer(Filter):
|
|
"""
|
|
Filter which represents a 15 band equalizer.
|
|
You can adjust the dynamic of the sound using this filter.
|
|
i.e: Applying a bass boost filter to emphasize the bass in a song.
|
|
The format for the levels is: List[Tuple[int, float]]
|
|
"""
|
|
|
|
def __init__(self, *, tag: str, levels: list):
|
|
super().__init__()
|
|
|
|
self.eq = self._factory(levels)
|
|
self.raw = levels
|
|
|
|
self.payload = {"equalizer": self.eq}
|
|
self.tag = tag
|
|
|
|
def _factory(self, levels: list):
|
|
_dict = collections.defaultdict(int)
|
|
|
|
_dict.update(levels)
|
|
_dict = [{"band": i, "gain": _dict[i]} for i in range(15)]
|
|
|
|
return _dict
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Pomice.EqualizerFilter tag={self.tag} eq={self.eq} raw={self.raw}>"
|
|
|
|
@classmethod
|
|
def flat(cls):
|
|
"""Equalizer preset which represents a flat EQ board,
|
|
with all levels set to their default values.
|
|
"""
|
|
|
|
levels = [
|
|
(0, 0.0), (1, 0.0), (2, 0.0), (3, 0.0), (4, 0.0),
|
|
(5, 0.0), (6, 0.0), (7, 0.0), (8, 0.0), (9, 0.0),
|
|
(10, 0.0), (11, 0.0), (12, 0.0), (13, 0.0), (14, 0.0)
|
|
]
|
|
return cls(tag="flat", levels=levels)
|
|
|
|
@classmethod
|
|
def boost(cls):
|
|
"""Equalizer preset which boosts the sound of a track,
|
|
making it sound fun and energetic by increasing the bass
|
|
and the highs.
|
|
"""
|
|
|
|
levels = [
|
|
(0, -0.075), (1, 0.125), (2, 0.125), (3, 0.1), (4, 0.1),
|
|
(5, .05), (6, 0.075), (7, 0.0), (8, 0.0), (9, 0.0),
|
|
(10, 0.0), (11, 0.0), (12, 0.125), (13, 0.15), (14, 0.05)
|
|
]
|
|
return cls(tag="boost", levels=levels)
|
|
|
|
@classmethod
|
|
def metal(cls):
|
|
"""Equalizer preset which increases the mids of a track,
|
|
preferably one of the metal genre, to make it sound
|
|
more full and concert-like.
|
|
"""
|
|
|
|
levels = [
|
|
(0, 0.0), (1, 0.1), (2, 0.1), (3, 0.15), (4, 0.13),
|
|
(5, 0.1), (6, 0.0), (7, 0.125), (8, 0.175), (9, 0.175),
|
|
(10, 0.125), (11, 0.125), (12, 0.1), (13, 0.075), (14, 0.0)
|
|
]
|
|
|
|
return cls(tag="metal", levels=levels)
|
|
|
|
@classmethod
|
|
def piano(cls):
|
|
"""Equalizer preset which increases the mids and highs
|
|
of a track, preferably a piano based one, to make it
|
|
stand out.
|
|
"""
|
|
|
|
levels = [
|
|
(0, -0.25), (1, -0.25), (2, -0.125), (3, 0.0),
|
|
(4, 0.25), (5, 0.25), (6, 0.0), (7, -0.25), (8, -0.25),
|
|
(9, 0.0), (10, 0.0), (11, 0.5), (12, 0.25), (13, -0.025)
|
|
]
|
|
return cls(tag="piano", levels=levels)
|
|
|
|
|
|
class Timescale(Filter):
|
|
"""Filter which changes the speed and pitch of a track.
|
|
You can make some very nice effects with this filter,
|
|
i.e: a vaporwave-esque filter which slows the track down
|
|
a certain amount to produce said effect.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag: str,
|
|
speed: float = 1.0,
|
|
pitch: float = 1.0,
|
|
rate: float = 1.0
|
|
):
|
|
super().__init__()
|
|
|
|
if speed < 0:
|
|
raise FilterInvalidArgument("Timescale speed must be more than 0.")
|
|
if pitch < 0:
|
|
raise FilterInvalidArgument("Timescale pitch must be more than 0.")
|
|
if rate < 0:
|
|
raise FilterInvalidArgument("Timescale rate must be more than 0.")
|
|
|
|
self.speed = speed
|
|
self.pitch = pitch
|
|
self.rate = rate
|
|
self.tag = tag
|
|
|
|
self.payload = {"timescale": {"speed": self.speed,
|
|
"pitch": self.pitch,
|
|
"rate": self.rate}}
|
|
|
|
@classmethod
|
|
def vaporwave(cls):
|
|
"""Timescale preset which slows down the currently playing track,
|
|
giving it the effect of a half-speed record/casette playing.
|
|
|
|
This preset will assign the tag 'vaporwave'.
|
|
"""
|
|
|
|
return cls(tag="vaporwave", speed=0.8, pitch=0.8)
|
|
|
|
@classmethod
|
|
def nightcore(cls):
|
|
"""Timescale preset which speeds up the currently playing track,
|
|
which matches up to nightcore, a genre of sped-up music
|
|
|
|
This preset will assign the tag 'nightcore'.
|
|
"""
|
|
|
|
return cls(tag="nightcore", speed=1.25, pitch=1.3)
|
|
|
|
def __repr__(self):
|
|
return f"<Pomice.TimescaleFilter tag={self.tag} speed={self.speed} pitch={self.pitch} rate={self.rate}>"
|
|
|
|
|
|
class Karaoke(Filter):
|
|
"""Filter which filters the vocal track from any song and leaves the instrumental.
|
|
Best for karaoke as the filter implies.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag: str,
|
|
level: float = 1.0,
|
|
mono_level: float = 1.0,
|
|
filter_band: float = 220.0,
|
|
filter_width: float = 100.0
|
|
):
|
|
super().__init__()
|
|
|
|
self.level = level
|
|
self.mono_level = mono_level
|
|
self.filter_band = filter_band
|
|
self.filter_width = filter_width
|
|
self.tag = tag
|
|
|
|
self.payload = {"karaoke": {"level": self.level,
|
|
"monoLevel": self.mono_level,
|
|
"filterBand": self.filter_band,
|
|
"filterWidth": self.filter_width}}
|
|
|
|
def __repr__(self):
|
|
return (
|
|
f"<Pomice.KaraokeFilter tag={self.tag} level={self.level} mono_level={self.mono_level} "
|
|
f"filter_band={self.filter_band} filter_width={self.filter_width}>"
|
|
)
|
|
|
|
|
|
class Tremolo(Filter):
|
|
"""Filter which produces a wavering tone in the music,
|
|
causing it to sound like the music is changing in volume rapidly.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag: str,
|
|
frequency: float = 2.0,
|
|
depth: float = 0.5
|
|
):
|
|
super().__init__()
|
|
|
|
if frequency < 0:
|
|
raise FilterInvalidArgument(
|
|
"Tremolo frequency must be more than 0.")
|
|
if depth < 0 or depth > 1:
|
|
raise FilterInvalidArgument(
|
|
"Tremolo depth must be between 0 and 1.")
|
|
|
|
self.frequency = frequency
|
|
self.depth = depth
|
|
self.tag = tag
|
|
|
|
self.payload = {"tremolo": {"frequency": self.frequency,
|
|
"depth": self.depth}}
|
|
|
|
def __repr__(self):
|
|
return f"<Pomice.TremoloFilter tag={self.tag} frequency={self.frequency} depth={self.depth}>"
|
|
|
|
|
|
class Vibrato(Filter):
|
|
"""Filter which produces a wavering tone in the music, similar to the Tremolo filter,
|
|
but changes in pitch rather than volume.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag: str,
|
|
frequency: float = 2.0,
|
|
depth: float = 0.5
|
|
):
|
|
|
|
super().__init__()
|
|
if frequency < 0 or frequency > 14:
|
|
raise FilterInvalidArgument(
|
|
"Vibrato frequency must be between 0 and 14.")
|
|
if depth < 0 or depth > 1:
|
|
raise FilterInvalidArgument(
|
|
"Vibrato depth must be between 0 and 1.")
|
|
|
|
self.frequency = frequency
|
|
self.depth = depth
|
|
self.tag = tag
|
|
|
|
self.payload = {"vibrato": {"frequency": self.frequency,
|
|
"depth": self.depth}}
|
|
|
|
def __repr__(self):
|
|
return f"<Pomice.VibratoFilter tag={self.tag} frequency={self.frequency} depth={self.depth}>"
|
|
|
|
|
|
class Rotation(Filter):
|
|
"""Filter which produces a stereo-like panning effect, which sounds like
|
|
the audio is being rotated around the listener's head
|
|
"""
|
|
|
|
def __init__(self, *, tag: str, rotation_hertz: float = 5):
|
|
super().__init__()
|
|
|
|
self.rotation_hertz = rotation_hertz
|
|
self.tag = tag
|
|
self.payload = {"rotation": {"rotationHz": self.rotation_hertz}}
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Pomice.RotationFilter tag={self.tag} rotation_hertz={self.rotation_hertz}>"
|
|
|
|
|
|
class ChannelMix(Filter):
|
|
"""Filter which manually adjusts the panning of the audio, which can make
|
|
for some cool effects when done correctly.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag: str,
|
|
left_to_left: float = 1,
|
|
right_to_right: float = 1,
|
|
left_to_right: float = 0,
|
|
right_to_left: float = 0
|
|
):
|
|
super().__init__()
|
|
|
|
if 0 > left_to_left > 1:
|
|
raise ValueError(
|
|
"'left_to_left' value must be more than or equal to 0 or less than or equal to 1.")
|
|
if 0 > right_to_right > 1:
|
|
raise ValueError(
|
|
"'right_to_right' value must be more than or equal to 0 or less than or equal to 1.")
|
|
if 0 > left_to_right > 1:
|
|
raise ValueError(
|
|
"'left_to_right' value must be more than or equal to 0 or less than or equal to 1.")
|
|
if 0 > right_to_left > 1:
|
|
raise ValueError(
|
|
"'right_to_left' value must be more than or equal to 0 or less than or equal to 1.")
|
|
|
|
self.left_to_left = left_to_left
|
|
self.left_to_right = left_to_right
|
|
self.right_to_left = right_to_left
|
|
self.right_to_right = right_to_right
|
|
self.tag = tag
|
|
|
|
self.payload = {"channelMix": {"leftToLeft": self.left_to_left,
|
|
"leftToRight": self.left_to_right,
|
|
"rightToLeft": self.right_to_left,
|
|
"rightToRight": self.right_to_right}
|
|
}
|
|
|
|
|
|
def __repr__(self) -> str:
|
|
return (
|
|
f"<Pomice.ChannelMix tag={self.tag} left_to_left={self.left_to_left} left_to_right={self.left_to_right} "
|
|
f"right_to_left={self.right_to_left} right_to_right={self.right_to_right}>"
|
|
)
|
|
|
|
class Distortion(Filter):
|
|
"""Filter which generates a distortion effect. Useful for certain filter implementations where
|
|
distortion is needed.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
*,
|
|
tag: str,
|
|
sin_offset: float = 0,
|
|
sin_scale: float = 1,
|
|
cos_offset: float = 0,
|
|
cos_scale: float = 1,
|
|
tan_offset: float = 0,
|
|
tan_scale: float = 1,
|
|
offset: float = 0,
|
|
scale: float = 1
|
|
):
|
|
super().__init__()
|
|
|
|
self.sin_offset = sin_offset
|
|
self.sin_scale = sin_scale
|
|
self.cos_offset = cos_offset
|
|
self.cos_scale = cos_scale
|
|
self.tan_offset = tan_offset
|
|
self.tan_scale = tan_scale
|
|
self.offset = offset
|
|
self.scale = scale
|
|
self.tag = tag
|
|
|
|
self.payload = {"distortion": {
|
|
"sinOffset": self.sin_offset,
|
|
"sinScale": self.sin_scale,
|
|
"cosOffset": self.cos_offset,
|
|
"cosScale": self.cos_scale,
|
|
"tanOffset": self.tan_offset,
|
|
"tanScale": self.tan_scale,
|
|
"offset": self.offset,
|
|
"scale": self.scale
|
|
}}
|
|
|
|
def __repr__(self) -> str:
|
|
return (
|
|
f"<Pomice.Distortion tag={self.tag} sin_offset={self.sin_offset} sin_scale={self.sin_scale}> "
|
|
f"cos_offset={self.cos_offset} cos_scale={self.cos_scale} tan_offset={self.tan_offset} "
|
|
f"tan_scale={self.tan_scale} offset={self.offset} scale={self.scale}"
|
|
)
|
|
|
|
|
|
class LowPass(Filter):
|
|
"""Filter which supresses higher frequencies and allows lower frequencies to pass.
|
|
You can also do this with the Equalizer filter, but this is an easier way to do it.
|
|
"""
|
|
def __init__(self, *, tag: str, smoothing: float = 20):
|
|
super().__init__()
|
|
|
|
self.smoothing = smoothing
|
|
self.tag = tag
|
|
self.payload = {"lowPass": {"smoothing": self.smoothing}}
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Pomice.LowPass tag={self.tag} smoothing={self.smoothing}>"
|
|
|
|
|