shaderflow 0.4.0.dev1__py2.py3-none-any.whl

ShaderFlow/Modules/Piano.py

@@ -0,0 +1,362 @@
+import hashlib
+import itertools
+import shutil
+import struct
+import tempfile
+from collections import deque
+from pathlib import Path
+from typing import Any, Deque, Dict, Iterable, List, Optional, Tuple
+
+import numpy
+from attr import Factory, define
+
+from Broken import BROKEN, BrokenPath, BrokenPlatform, BrokenSpinner, log, shell
+from Broken.Externals.FFmpeg import BrokenFFmpeg
+from Broken.Types import BPM, Seconds
+from ShaderFlow.Common.Notes import BrokenPianoNote
+from ShaderFlow.Module import ShaderModule
+from ShaderFlow.Modules.Dynamics import DynamicNumber
+from ShaderFlow.Texture import ShaderTexture
+from ShaderFlow.Variable import ShaderVariable
+
+MAX_CHANNELS = 32
+MAX_ROLLING = 256
+MAX_NOTE = 128
+
+@define
+class ShaderPiano(ShaderModule):
+    name: str = "iPiano"
+    """Texture name prefixes for this Module"""
+
+    tempo: Deque[Tuple[Seconds, BPM]] = Factory(deque)
+    """List of tempo changes at (seconds, bpm)"""
+
+    keys_texture: ShaderTexture = None
+    """Velocities texture, X is MIDI index, Y is Velocity, size (MAX_NOTE, 1)"""
+
+    channel_texture: ShaderTexture = None
+    """Channel being played texture, X is MIDI index, Y is Channel, size (MAX_NOTE, 1)"""
+
+    roll_texture: ShaderTexture = None
+    """Piano roll'ling notes main texture'. The X coordinate is the MIDI index, pixels contains data
+    (start, end, channel, velocity), of each playing key on the Y. Size (MAX_ROLLING, MAX_NOTE)"""
+
+    time_offset: Seconds = 0
+    """Offset the notes being played search from the current time"""
+
+    roll_time: Seconds = 2
+    """How long the notes are visible, 'roll for'"""
+
+    height: float = 0.275
+    """Height of the piano in the shader (0-1)"""
+
+    black_ratio: float = 0.6
+    """How long are black keys compared to white keys"""
+
+    global_minimum_note: int = MAX_NOTE
+    """The lowest note in the loaded notes"""
+
+    global_maximum_note: int = 0
+    """The highest note in the loaded notes"""
+
+    extra_side_keys: int = 6
+    """Display the dynamic range plus this many keys on each side"""
+
+    future_range_lookup: Seconds = 2
+    """Lookup notes in (roll_time + this) for setting the dynamic ranges"""
+
+    release_before_end: Seconds = 0.05
+    """Workaround for the transition between close/glued to be perceived"""
+
+    key_press_dynamics: DynamicNumber = Factory(lambda: DynamicNumber(
+        value=numpy.zeros(MAX_NOTE, numpy.float32),
+        frequency=4, zeta=0.4, response=0, precision=0
+    ))
+
+    note_range_dynamics: DynamicNumber = Factory(lambda: DynamicNumber(
+        value=numpy.zeros(2, numpy.float32),
+        frequency=0.05, zeta=1/(2**0.5), response=0,
+    ))
+
+    tree: Dict[int, Dict[int, Deque[BrokenPianoNote]]] = Factory(dict)
+    """Internal data structure for storing the notes"""
+
+    @property
+    def lookup_time(self) -> Seconds:
+        """The full lookup time we should care for future notes (rolling+future range)"""
+        return (self.roll_time + self.future_range_lookup)
+
+    # # Internal
+
+    def __post__(self):
+        self.keys_texture    = ShaderTexture(scene=self.scene, name=f"{self.name}Keys").from_numpy(self._empty_keys())
+        self.channel_texture = ShaderTexture(scene=self.scene, name=f"{self.name}Chan").from_numpy(self._empty_keys())
+        self.roll_texture    = ShaderTexture(scene=self.scene, name=f"{self.name}Roll").from_numpy(self._empty_roll())
+        self.tempo_texture   = ShaderTexture(scene=self.scene, name=f"{self.name}Tempo").from_numpy(numpy.zeros((100, 1, 2), numpy.float32))
+
+    def _empty_keys(self) -> numpy.ndarray:
+        return numpy.zeros((MAX_NOTE, 1), numpy.float32)
+
+    def _empty_roll(self) -> numpy.ndarray:
+        return numpy.zeros((MAX_NOTE, MAX_ROLLING, 4), numpy.float32)
+
+    # # Data structure
+
+    @staticmethod
+    def _ranges(start: Seconds, end: Seconds) -> Iterable[int]:
+        return range(int(start), int(end)+1)
+
+    def clear(self):
+        self.tree.clear()
+
+    def add_note(self, note: Optional[BrokenPianoNote]) -> None:
+        if note is None:
+            return
+        for index in self._ranges(note.start, note.end):
+            self.tree.setdefault(note.note, dict()).setdefault(index, deque()).append(note)
+        self.update_global_ranges(note.note)
+
+    @property
+    def notes(self) -> Iterable[BrokenPianoNote]:
+        for block in self.tree.values():
+            for notes in block.values():
+                yield from notes
+
+    @property
+    def duration(self) -> float:
+        return max((note.end for note in self.notes), default=0)
+
+    def __iter__(self) -> Iterable[BrokenPianoNote]:
+        return self.notes
+
+    def notes_between(self, index: int, start: Seconds, end: Seconds) -> Iterable[BrokenPianoNote]:
+        exists = set()
+        for other in self._ranges(start, end):
+            for note in self.tree.get(index, dict()).get(other, deque()):
+                if (note.start > end):
+                    continue
+                if (id(note) in exists):
+                    continue
+                exists.add(id(note))
+                yield note
+
+    def update_global_ranges(self, note: int) -> None:
+        self.global_minimum_note = min(self.global_minimum_note, note)
+        self.global_maximum_note = max(self.global_maximum_note, note)
+
+    @property
+    def maximum_velocity(self) -> Optional[int]:
+        return max((note.velocity for note in self.notes), default=None)
+
+    @property
+    def minimum_velocity(self) -> Optional[int]:
+        return min((note.velocity for note in self.notes), default=None)
+
+    def normalize_velocities(self, minimum: int=100, maximum: int=100) -> None:
+        ma, mi = (self.maximum_velocity, self.minimum_velocity)
+
+        # Safe against (minimum-maximum=0)
+        def new(velocity: int) -> int:
+            if (ma==mi): return (maximum+minimum)//2
+            return int((velocity-mi)/(ma-mi)*(maximum-minimum)+minimum)
+
+        for note in self.notes:
+            note.velocity = new(note.velocity)
+
+    def load_midi(self, path: Path):
+        import pretty_midi
+
+        if not (path := BrokenPath(path)).exists():
+            log.warning(f"{self.who} Input Midi file not found ({path})")
+            return
+
+        with BrokenSpinner(log.info(f"Loading Midi file at ({path})")):
+            midi = pretty_midi.PrettyMIDI(str(path))
+            for channel, instrument in enumerate(midi.instruments):
+                if instrument.is_drum:
+                    pass
+                for note in instrument.notes:
+                    self.add_note(BrokenPianoNote(
+                        note=note.pitch,
+                        start=note.start,
+                        end=note.end,
+                        channel=channel,
+                        velocity=note.velocity,
+                    ))
+            # Add tempo changes
+            for when, tempo in zip(*midi.get_tempo_changes()):
+                self.tempo.append((when, tempo))
+
+        self.tempo_texture.clear()
+
+        for offset, (when, tempo) in enumerate(self.tempo):
+            self.tempo_texture.write(data=struct.pack("ff", when, tempo), viewport=(0, offset, 1, 1))
+
+    # # Core Logic
+
+    # A (MAX_MIDI Notes x MAX_CHANNELS Channels) matrix of the end-most note being played
+    _playing_matrix: List[List[Optional[BrokenPianoNote]]] = Factory(lambda: [[None]*MAX_CHANNELS for _ in range(MAX_NOTE)])
+
+    def update(self):
+
+        # Utilities and trackers
+        time = (self.scene.time + self.time_offset)
+        upcoming = set()
+
+        # # Get and update pressed keys
+        self.key_press_dynamics.target.fill(0)
+        roll = self._empty_roll()
+
+        # Channel '-1' means the note is not being played !
+        channels = (self._empty_keys() - 1)
+
+        # Optimization: No need to check for the entire range 😉
+        for midi in range(self.global_minimum_note, self.global_maximum_note+1):
+            simultaneous = 0
+
+            for note in self.notes_between(midi, time, time+self.lookup_time):
+                upcoming.add(midi)
+
+                # Ignore notes out of the viewport
+                if (note.start >= time+self.roll_time):
+                    continue
+
+                # Build a 2D Grid of the piano keys being played
+                # • Coordinate: (Note, #offset) @ (Start, End, Channel, Velocity)
+                if (simultaneous < MAX_ROLLING):
+                    roll[note.note, simultaneous] = (note.start, note.end, note.channel, note.velocity)
+                    simultaneous += 1
+
+                # Skip non-playing notes
+                if not (note.start <= time <= note.end):
+                    continue
+
+                # Workaround: Don't play the full note, so close notes velocities are perceived twice
+                _note_too_small = (note.end - note.start) < self.release_before_end
+                _shorter_note = (time < (note.end - self.release_before_end))
+
+                if (_shorter_note or _note_too_small):
+                    self.key_press_dynamics.target[midi] = note.velocity
+
+                # Either way, the channel must be colored
+                channels[midi] = note.channel
+
+                # Find empty slots or notes that will end soon, replace and play
+                other = self._playing_matrix[midi][note.channel]
+                if (other is None) or (other.end > note.end):
+                    play_velocity = int(128*((note.velocity/128)**0.5))
+                    self.fluid_key_down(midi, play_velocity, note.channel)
+                    self._playing_matrix[midi][note.channel] = note
+
+            # Find notes that are not being played
+            for channel in range(MAX_CHANNELS * self.scene.realtime):
+                if (other := self._playing_matrix[midi][channel]) and (other.end < time):
+                    self._playing_matrix[midi][channel] = None
+                    self.fluid_key_up(midi, other.channel)
+
+        # Dynamic zoom velocity based on future lookup
+        self.note_range_dynamics.frequency = 0.5/self.lookup_time
+
+        # Set dynamic note range to the globals on the start
+        if sum(self.note_range_dynamics.value) == 0:
+            self.note_range_dynamics.value[:] = (self.global_minimum_note, self.global_maximum_note)
+
+        # Set new targets for dynamic keys
+        self.note_range_dynamics.target[:] = (
+            min(upcoming, default=self.global_minimum_note),
+            max(upcoming, default=self.global_maximum_note)
+        )
+
+        # Write to keys textures
+        self.note_range_dynamics.next(dt=abs(self.scene.dt))
+        self.key_press_dynamics.next(dt=abs(self.scene.dt))
+        self.keys_texture.write(data=self.key_press_dynamics.value)
+        self.roll_texture.write(data=roll)
+        self.channel_texture.write(data=channels)
+
+    def pipeline(self) -> Iterable[ShaderVariable]:
+        yield ShaderVariable("uniform", "int",   f"{self.name}GlobalMin",  self.global_minimum_note)
+        yield ShaderVariable("uniform", "int",   f"{self.name}GlobalMax",  self.global_maximum_note)
+        yield ShaderVariable("uniform", "vec2",  f"{self.name}Dynamic",    self.note_range_dynamics.value)
+        yield ShaderVariable("uniform", "float", f"{self.name}RollTime",   self.roll_time)
+        yield ShaderVariable("uniform", "float", f"{self.name}Extra",      self.extra_side_keys)
+        yield ShaderVariable("uniform", "float", f"{self.name}Height",     self.height)
+        yield ShaderVariable("uniform", "int",   f"{self.name}Limit",      MAX_ROLLING)
+        yield ShaderVariable("uniform", "float", f"{self.name}BlackRatio", self.black_ratio)
+
+    # # Fluidsynth
+
+    fluidsynth: Any = None
+    soundfont:  Any = None
+
+    def fluid_load(self, sf2: Path, driver: str=("pulseaudio" if BrokenPlatform.OnLinux else None)) -> None:
+        if not (sf2 := BrokenPath(sf2)).exists():
+            log.warning(f"{self.who} Couldn't load SoundFont from path ({sf2}), will not have Real Time MIDI Audio")
+            return
+
+        # Download FluidSynth for Windows
+        if BrokenPlatform.OnWindows:
+            FLUIDSYNTH = "https://github.com/FluidSynth/fluidsynth/releases/download/v2.3.4/fluidsynth-2.3.4-win10-x64.zip"
+            BrokenPath.add_to_path(BrokenPath.extract(BrokenPath.download(FLUIDSYNTH), BROKEN.DIRECTORIES.EXTERNALS), recurse=True)
+        elif BrokenPlatform.OnMacOS:
+            if not shutil.which("fluidsynth"):
+                shell("brew", "install", "fluidsynth")
+        elif BrokenPlatform.OnLinux:
+            log.minor(f"{self.who} Please install FluidSynth in your Package Manager if needed")
+
+        import fluidsynth
+        self.fluidsynth = fluidsynth.Synth()
+        with BrokenSpinner(log.info(f"Loading FluidSynth SoundFont ({sf2.name})")):
+            self.soundfont = self.fluidsynth.sfload(str(sf2))
+        self.fluidsynth.set_reverb(1, 1, 80, 1)
+        self.fluidsynth.start(driver=driver)
+        for channel in range(MAX_CHANNELS):
+            self.fluid_select(channel, 0, 0)
+
+    def fluid_select(self, channel: int=0, bank: int=0, preset: int=0) -> None:
+        if self.fluidsynth:
+            self.fluidsynth.program_select(channel, self.soundfont, bank, preset)
+
+    def fluid_key_down(self, note: int, velocity: int=127, channel: int=0) -> None:
+        if self.fluidsynth:
+            self.fluidsynth.noteon(channel, note, velocity)
+
+    def fluid_key_up(self, note: int, channel: int=0) -> None:
+        if self.fluidsynth:
+            self.fluidsynth.noteoff(channel, note)
+
+    def fluid_all_notes_off(self) -> None:
+        if self.fluidsynth:
+            for channel, note in itertools.product(range(MAX_CHANNELS), range(MAX_NOTE)):
+                self.fluidsynth.noteoff(channel, note)
+
+    def fluid_render(self,
+        midi: Path,
+        soundfont: Path=None,
+        output: Path=None
+    ) -> Path:
+        if not self.fluidsynth:
+            return
+
+        # Get temporary cached file
+        if output is None:
+            midi_hash = hashlib.md5(BrokenPath(midi).read_bytes()).hexdigest()
+            output = Path(tempfile.gettempdir())/f"ShaderFlow-Midi2Audio-{midi_hash}.wav"
+
+        import midi2audio
+        with BrokenSpinner(log.info(f"Rendering FluidSynth Midi ({midi}) → ({output})")):
+            midi2audio.FluidSynth(soundfont).midi_to_audio(midi, output)
+
+        # Normalize audio with FFmpeg
+        normalized = output.with_suffix(".aac")
+        with BrokenSpinner(log.info(f"Normalizing Audio ({output}) → ({normalized})")):
+            (BrokenFFmpeg()
+                .quiet()
+                .overwrite()
+                .input(output)
+                .filter("loudnorm")
+                .aac()
+                .output(normalized)
+            ).run()
+
+        return BrokenPath(normalized)

ShaderFlow/Modules/Spectrogram.py

@@ -0,0 +1,315 @@
+import functools
+from math import pi
+from typing import Callable, Iterable, Tuple, Union
+
+import cachetools
+import numpy
+import scipy
+from attr import Factory, define, field
+
+from Broken import SameTracker, log
+from Broken.Types import Hertz, Samples, Seconds
+from ShaderFlow.Common.Notes import BrokenPianoNote
+from ShaderFlow.Module import ShaderModule
+from ShaderFlow.Modules.Audio import BrokenAudio
+from ShaderFlow.Modules.Dynamics import DynamicNumber
+from ShaderFlow.Texture import ShaderTexture, TextureType
+from ShaderFlow.Variable import ShaderVariable
+
+
+class BrokenAudioFourierMagnitude:
+    """Given an raw FFT, interpret the complex number as some size"""
+    def Amplitude(x: numpy.ndarray) -> numpy.ndarray:
+        return numpy.abs(x)
+
+    def Power(x: numpy.ndarray) -> numpy.ndarray:
+        return x*x.conjugate()
+
+class BrokenAudioFourierVolume:
+    """Convert the FFT into the final spectrogram's magnitude bin"""
+
+    def dBFS(x: numpy.ndarray) -> numpy.ndarray:
+        return 10*numpy.log10(x)
+
+    def Sqrt(x: numpy.ndarray) -> numpy.ndarray:
+        return numpy.sqrt(x)
+
+    def Linear(x: numpy.ndarray) -> numpy.ndarray:
+        return x
+
+    def dBFsTremx(x: numpy.ndarray) -> numpy.ndarray:
+        return 10*(numpy.log10(x+0.1) + 1)/1.0414
+
+
+class BrokenAudioSpectrogramInterpolation:
+    """Interpolate the FFT values, discrete to continuous"""
+    #
+    # I can explain this better later, but the idea is here:
+    # • https://www.desmos.com/calculator/vvixdoooty
+    # • https://en.wikipedia.org/wiki/Whittaker%E2%80%93Shannon_interpolation_formula
+    #
+    # Sinc(x) is already normalized (divided by the area, pi) as in sinc(x) = sin(pi*x)/(pi*x).
+    #
+    # The general case for a interpolation formula is to normalize some function f(x) by its area.
+    # For example, in the case of exp(-x^2) as the function, its area is the  magical sqrt(pi)
+    # as seen in @3b1b https://www.youtube.com/watch?v=cy8r7WSuT1I
+    #
+
+    # Note: A value above 1.54 is recommended
+    def make_euler(end: float=1.54) -> Callable:
+        return (lambda x: numpy.exp(-(2*x/end)**2) / (end*(pi**0.5)))
+
+    def Dirac(x):
+        dirac = numpy.zeros(x.shape)
+        dirac[numpy.round(x) == 0] = 1
+        return dirac
+
+    Euler = make_euler(end=1.2)
+
+    def Sinc(x: numpy.ndarray) -> numpy.ndarray:
+        return numpy.abs(numpy.sinc(x))
+
+
+class BrokenAudioSpectrogramScale:
+    """Functions that defines the y scale of the spectrogram. Tuples of f(x) and f^-1(x)"""
+
+    # Octave, matches the piano keys
+    # Todo: Make a generic base exponent?
+    Octave = (
+        lambda x: (numpy.log(x)/numpy.log(2)),
+        lambda x: (2**x)
+    )
+
+    # Personally not a big fan
+    MEL = (
+        lambda x: 2595 * numpy.log10(1 + x/700),
+        lambda x: 700 * (10**(x/2595) - 1),
+    )
+
+
+class BrokenAudioSpectrogramWindow:
+
+    @functools.lru_cache
+    def hann_poisson_window(N: int, alpha: float=2) -> numpy.ndarray:
+        """
+        Generate a Hann-Poisson window
+
+        Args:
+            N: The number of window samples
+            alpha: Slope of the exponential
+
+        Returns:
+            numpy.array: Window samples
+        """
+        n = numpy.arange(N)
+        hann    = 0.5 * (1 - numpy.cos(2 * numpy.pi * n / N))
+        poisson = numpy.exp(-alpha * numpy.abs(N - 2*n) / N)
+        return hann * poisson
+
+    @functools.lru_cache
+    def hanning(size: int) -> numpy.ndarray:
+        """Returns a hanning window of the given size"""
+        return numpy.hanning(size)
+
+    @functools.lru_cache
+    def none(size: int) -> numpy.ndarray:
+        """Returns a none window of the given size"""
+        return numpy.ones(size)
+
+
+@define(slots=False)
+class BrokenSpectrogram:
+    audio: BrokenAudio = Factory(BrokenAudio)
+
+    fft_n: int = field(default=12, converter=int)
+    """2^n FFT size, higher values, higher frequency resolution, less responsiveness"""
+
+    sample_rateio: int = field(default=1, converter=int)
+    """Resample the input data by a factor, int for FFT optimizations"""
+
+    # Spectrogram properties
+    scale:        Tuple[callable] = BrokenAudioSpectrogramScale.Octave
+    interpolation:      callable  = BrokenAudioSpectrogramInterpolation.Euler
+    magnitude_function: callable  = BrokenAudioFourierMagnitude.Power
+    window_function:    callable  = BrokenAudioSpectrogramWindow.hanning
+    volume:             callable  = BrokenAudioFourierVolume.Sqrt
+
+    def __cache__(self) -> int:
+        return hash((
+            self.fft_n,
+            self.minimum_frequency,
+            self.maximum_frequency,
+            self.spectrogram_bins,
+            self.sample_rateio,
+            self.magnitude_function,
+            self.interpolation,
+            self.scale,
+            self.volume,
+        ))
+
+    # # Fourier
+
+    @property
+    def fft_size(self) -> Samples:
+        return int(2**(self.fft_n) * self.sample_rateio)
+
+    @property
+    def fft_bins(self) -> int:
+        return int(self.fft_size/2 + 1)
+
+    @property
+    def fft_frequencies(self) -> Union[numpy.ndarray, Hertz]:
+        return numpy.fft.rfftfreq(self.fft_size, 1/(self.audio.samplerate*self.sample_rateio))
+
+    def fft(self) -> numpy.ndarray:
+        data = self.audio.get_last_n_samples(int(2**self.fft_n))
+
+        # Optionally resample the data
+        if self.sample_rateio != 1:
+            try:
+                import samplerate
+            except ModuleNotFoundError:
+                raise RuntimeError('\n'.join((
+                    "Please install 'samplerate' optional dependency for resampling:"
+                    "• Find it at: (https://pypi.org/project/samplerate)"
+                    "• From Source (Rye): 'rye sync --features samplerate'"
+                    "• From PIP: 'pip install broken-source[samplerate]'"
+                )))
+            data = numpy.array([samplerate.resample(x, self.sample_rateio, 'linear') for x in data])
+
+        return self.magnitude_function(
+            numpy.fft.rfft(self.window_function(self.fft_size) * data)
+        ).astype(self.audio.dtype)
+
+    # # Spectrogram
+
+    def next(self) -> numpy.ndarray:
+        return self.spectrogram_matrix.dot(self.fft().T).T
+        return self.volume([
+            self.spectrogram_matrix @ channel
+            for channel in self.fft()
+        ])
+
+    minimum_frequency: Hertz = 20.0
+    maximum_frequency: Hertz = 20000.0
+    spectrogram_bins:  int   = 1000
+
+    @property
+    def spectrogram_frequencies(self) -> numpy.ndarray:
+        return self.scale[1](numpy.linspace(
+            self.scale[0](self.minimum_frequency),
+            self.scale[0](self.maximum_frequency),
+            self.spectrogram_bins,
+        ))
+
+    @property
+    @cachetools.cached(cache={}, key=lambda self: self.__cache__())
+    def spectrogram_matrix(self) -> scipy.sparse.csr_matrix:
+        """
+        Gets a transformation matrix that multiplied with self.fft yields "spectrogram bins" in custom scale
+
+        The idea to get the center frequencies on the custom scale is to compute the following:
+        $$ center_frequencies = T^-1(linspace(T(min), T(max), n)) $$
+
+        Where T(f) transforms a frequency to some scale (done in self.spectrogram_frequencies)
+
+        And then create many band-pass filters, each one centered on the center frequencies using
+        Whittaker-Shannon's interpolation formula per row of the matrix, considering the FFT bins as
+        a one-hertz-frequency function to interpolate, we find "the around frequencies" !
+        """
+
+        # Whittaker-Shannon interpolation formula per row of the matrix
+        matrix = numpy.array([
+            self.interpolation(theoretical_index - numpy.arange(self.fft_bins))
+            for theoretical_index in (self.spectrogram_frequencies/self.fft_frequencies[1])
+        ], dtype=self.audio.dtype)
+
+        # Zero out near-zero values
+        matrix[numpy.abs(matrix) < 1e-5] = 0
+
+        # Create a scipy sparse for much faster matrix multiplication
+        return scipy.sparse.csr_matrix(matrix)
+
+    def from_notes(self,
+        start: BrokenPianoNote,
+        end: BrokenPianoNote,
+        bins: int=1000,
+        piano: bool=False,
+        tuning: Hertz=440,
+    ):
+        start = BrokenPianoNote.get(start, tuning=tuning)
+        end   = BrokenPianoNote.get(end, tuning=tuning)
+        log.info(f"Making Spectrogram Piano Matrix from notes ({start.name} - {end.name})")
+        self.minimum_frequency = start.frequency
+        self.maximum_frequency = end.frequency
+        if not piano:
+            self.spectrogram_bins = bins
+        else:
+            # The advertised number of bins should start and end on a note
+            half_semitone = 2**(0.5/12)
+            self.spectrogram_bins = ((end.note - start.note) + 1)
+            self.minimum_frequency /= half_semitone
+            self.maximum_frequency *= half_semitone
+
+# -------------------------------------------------------------------------------------------------|
+
+@define
+class ShaderSpectrogram(BrokenSpectrogram, ShaderModule):
+    name: str = "iSpectrogram"
+    """Prefix name and Texture name of the Shader Variables"""
+
+    length: Seconds = 5
+    """Horizontal length of the Spectrogram content"""
+
+    offset: Samples = 0
+    """Modulus of total samples written by length, used for scrolling mode"""
+
+    smooth: bool = False
+    """Enables Linear interpolation on the Texture, not useful for Bars mode"""
+
+    scrolling: bool = False
+    """"""
+
+    dynamics: DynamicNumber = None
+    """Apply Dynamics to the FFT data"""
+
+    texture: ShaderTexture = None
+    """Internal managed Texture"""
+
+    @property
+    def length_samples(self) -> Samples:
+        return int(max(1, self.length*self.scene.fps))
+
+    def __post__(self):
+        self.dynamics = DynamicNumber(frequency=4, zeta=1, response=0)
+        self.texture = ShaderTexture(
+            scene=self.scene,
+            name=self.name,
+            dtype=TextureType.f4,
+            repeat_y=False,
+        )
+
+    __same__: SameTracker = Factory(SameTracker)
+
+    def update(self):
+        self.texture.components = self.audio.channels
+        self.texture.filter = ("linear" if self.smooth else "nearest")
+        self.texture.height = self.spectrogram_bins
+        self.texture.width = self.length_samples
+        self.offset = (self.offset + 1) % self.length_samples
+        if not self.__same__(self.audio.tell):
+            self.dynamics.target = self.next().T.reshape(2, -1)
+        self.dynamics.next(dt=abs(self.scene.dt))
+        self.texture.write(
+            viewport=(self.offset, 0, 1, self.spectrogram_bins),
+            data=self.dynamics.value,
+        )
+
+    def pipeline(self) -> Iterable[ShaderVariable]:
+        yield ShaderVariable("uniform", "int",   f"{self.name}Length", self.length_samples)
+        yield ShaderVariable("uniform", "int",   f"{self.name}Bins",   self.spectrogram_bins)
+        yield ShaderVariable("uniform", "float", f"{self.name}Offset", self.offset/self.length_samples)
+        yield ShaderVariable("uniform", "int",   f"{self.name}Smooth", self.smooth)
+        yield ShaderVariable("uniform", "float", f"{self.name}Min",    self.spectrogram_frequencies[0])
+        yield ShaderVariable("uniform", "float", f"{self.name}Max",    self.spectrogram_frequencies[-1])
+        yield ShaderVariable("uniform", "bool",  f"{self.name}Scroll", self.scrolling)