CREATE

fusion.py

@@ -0,0 +1,161 @@
+import os
+
+import soundfile
+from pydub import AudioSegment
+from pedalboard import (
+    Pedalboard,
+    Reverb,
+)
+
+
+class Fusion(AudioSegment):
+    class InvalidMusicFileError(Exception):
+        def __init__(self, file_name):
+            self.file_name = file_name
+            super().__init__(f"Invalid music file: {file_name}. File not found or not recognized as a valid music file.")
+
+    @classmethod
+    async def loadSound(cls, inputFile: str):
+        """
+        Loads and returns the MP3 or WAV (whichever is found) source sound file.
+        Stops program execution if file not found.
+        """
+
+        if os.path.isfile(inputFile) and inputFile.lower().endswith(('.mp3', '.wav', '.aac', '.ogg', '.flac', '.m4a')):
+            return cls.from_file(inputFile, format=inputFile.split(".")[-1])
+        else:
+            raise cls.InvalidMusicFileError(inputFile)
+
+    @classmethod
+    async def effect8D(
+        cls,
+        sound,
+        panBoundary: int = 100,  # Perctange of dist from center that audio source can go
+        jumpPercentage: int = 5,  # Percentage of dist b/w L-R to jump at a time
+        timeLtoR: int = 10000,  # Time taken for audio source to move from left to right in ms
+        volumeMultiplier: int = 6  # Max volume DB increase at edges
+    ):
+        """
+        Generates the 8d sound effect by splitting the audio into multiple smaller pieces,
+        pans each piece to make the sound source seem like it is moving from L to R and R to L in loop,
+        decreases volume towards center position to make the movement sound like it is a circle
+        instead of straight line.
+        """
+        piecesCtoR = panBoundary / jumpPercentage
+
+        # Total pieces when audio source moves from extreme left to extreme right
+        piecesLtoR = piecesCtoR * 2
+
+        # Time length of each piece
+        pieceTime = int(timeLtoR / piecesLtoR)
+
+        pan = []
+        left = -panBoundary  # Audio source to start from extreme left
+
+        while left <= panBoundary:  # Until audio source position reaches extreme right
+            pan.append(left)  # Append the position to pan array
+            left += jumpPercentage  # Increment to next position
+
+        # Above loop generates number in range -100 to 100, this converts it to -1.0 to 1.0 scale
+        pan = [x / 100 for x in pan]
+
+        sound8d = sound[0]  # Stores the 8d sound
+        panIndex = 0  # Index of current pan position of pan array
+
+        # We loop through the pan array forward once, and then in reverse (L to R, then R to L)
+        iteratePanArrayForward = True
+
+        # Loop through starting time of each piece
+        for time in range(0, len(sound) - pieceTime, pieceTime):
+
+            # time + pieceTime = ending time of piece
+            piece = sound[time : time + pieceTime]
+
+            # If at first element of pan array (Left) then iterate forward
+            if panIndex == 0:
+                iteratePanArrayForward = True
+
+            # If at last element of pan array (Right) then iterate backward
+            if panIndex == len(pan) - 1:
+                iteratePanArrayForward = False
+
+            # (panBoundary / 100) brings panBoundary to the same scale as elements of pan array i.e. -1.0 to 1.0
+            # abs(pan[panIndex]) / (panBoundary / 100) = 1 for extreme left/right and 0 for center
+            # abs(pan[panIndex]) / (panBoundary / 100) * volumeMultiplier = volumeMultiplier for extreme left/right and 0 for center
+            # Hence, volAdjust = 0 for extreme left/right and volumeMultiplier for center
+            volAdjust = volumeMultiplier - (
+                abs(pan[panIndex]) / (panBoundary / 100) * volumeMultiplier
+            )
+
+            # Decrease piece volume by volAdjust i.e. max volume at extreme left/right and decreases towards center
+            piece -= volAdjust
+
+            # Pan the piece of sound according to the pan array element
+            pannedPiece = piece.pan(pan[panIndex])
+
+            # Iterates the pan array from left to right, then right to left, then left to right and so on..
+            if iteratePanArrayForward:
+                panIndex += 1
+            else:
+                panIndex -= 1
+
+            # Add this panned piece of sound with adjusted volume to the 8d sound
+            sound8d = sound8d + pannedPiece
+
+        return sound8d
+
+    @classmethod
+    async def effectSlowed(cls, sound, speedMultiplier: float = 0.92 ): # Slowdown audio, 1.0 means original speed, 0.5 half speed etc
+        """
+        Increases sound frame rate to slow it down.
+        Returns slowed down version of the sound.
+        """
+
+        soundSlowedDown = sound._spawn(
+            sound.raw_data,
+            overrides={"frame_rate": int(sound.frame_rate * speedMultiplier)},
+        )
+        soundSlowedDown.set_frame_rate(sound.frame_rate)
+        return soundSlowedDown
+
+
+    @classmethod
+    async def effectReverb(
+        cls,
+        sound,
+        roomSize: float = 0.8, 
+        damping: float = 1,
+        width : float = 0.5,
+        wetLevel: float = 0.3,
+        dryLevel: float= 0.8,
+        tempFile: str = "tempWavFileForReverb"
+    ):
+        """
+        Adds reverb effect to the sound.
+        """
+        outputFile = tempFile+".wav"
+        # Convert the sound to a format usable by the pedalboard library
+        with open(outputFile, "wb") as out_f:
+            sound.export(out_f, format="wav")
+        sound, sampleRate = soundfile.read(outputFile)
+
+        # Define the reverb settings
+        addReverb = Pedalboard(
+            [Reverb(room_size=roomSize, damping=damping, width=width, wet_level=wetLevel, dry_level=dryLevel)]
+        )
+
+        # Add the reverb effect to the sound and return
+        reverbedSound = addReverb(sound, sample_rate=sampleRate)
+        with soundfile.SoundFile(outputFile, "w", samplerate=sampleRate, channels=sound.shape[1]) as f:
+            f.write(sound)
+        sound = cls.from_wav(outputFile)
+        os.remove(outputFile)
+        return sound
+
+    @classmethod
+    async def saveSound(cls, sound, outputFile: str = "output"):
+        """
+        Save the sound in MP3 format.
+        """
+        sound.export(outputFile + ".mp3", format="mp3")
+        return f"{outputFile}.mp3"