xylo player

app.py

@@ -0,0 +1,91 @@
+from interactive_pipe import interactive_pipeline, interactive, Control, Image
+from synthetizer import NOTE_FREQUENCIES, get_note
+from interactive_pipe.data_objects.audio import Audio
+from pathlib import Path
+from time import sleep
+import argparse
+import cv2
+import numpy as np
+
+
+def select_note(note="C4", context=None):
+    context["note"] = note
+
+
+def create_note(context={}):
+    note = context.get("note", "C4")
+    audio_signal = get_note(note)
+    return audio_signal
+
+
+def play_note(audio_signal: np.ndarray, context={}):
+    note = context.get("note", "C4")
+    file_name = Path(f"__{note}.wav")
+    if not file_name.exists():
+        Audio.save_audio(audio_signal, str(file_name), 44100)
+        while not file_name.exists():
+            sleep(0.01)
+            print("waiting for file")
+    assert file_name.exists()
+    context["__set_audio"](file_name)
+    context["__play"]()
+
+
+def display_color(context={}):
+    note = context.get("note", "C4")
+    return get_color(note,  size=(256, 256))
+
+
+def get_color(note, size=(256, 256)):
+    colors = {
+        "red": (1.0, 0.0, 0.0),
+        "orange": (1.0, 0.65, 0.0),
+        "yellow": (1.0, 1.0, 0.0),
+        "green": (0.0, 0.5, 0.0),
+        "blue": (0.0, 0.0, 1.0),
+        "dark blue": (0.0, 0.0, 0.55),
+        "purple": (0.5, 0.0, 0.5),
+        "pink": (1.0, 0.75, 0.8)
+    }
+    notes_translation = ["DO", "RE", "MI", "FA", "SOL", "LA", "SI", "DO"]
+    index = list(NOTE_FREQUENCIES.keys()).index(note)
+    color = colors.get(list(colors.keys())[index], [0., 0., 0.])
+    img = np.ones((size[1], size[0], 3)) * np.array(color)[None, None, :]
+    text = notes_translation[index]
+    font_scale = 4
+    thickness = 2
+    text_size = cv2.getTextSize(
+        text, cv2.FONT_HERSHEY_SIMPLEX, font_scale, thickness)[0]
+    text_x = (size[0] - text_size[0]) // 2
+    text_y = (size[1] + text_size[1]) // 2
+    cv2.putText(
+        img,
+        text,
+        (text_x, text_y),
+        cv2.FONT_HERSHEY_SIMPLEX, font_scale, (0, 0, 0), thickness
+    )
+    return img
+
+
+def xylo_player():
+    select_note()
+    audio = create_note()
+    play_note(audio)
+    out_image = display_color()
+    return out_image
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Xylophone synthesizer')
+    parser.add_argument('-b', '--backend', type=str,
+                        default='gradio', choices=['gradio', 'qt'])
+    args = parser.parse_args()
+    all_notes = list(NOTE_FREQUENCIES.keys())
+    icon_list = [Path(f"__{note}.jpg") for note in all_notes]
+    for note, icon in zip(all_notes, icon_list):
+        img = get_color(note, size=(512, 512))
+        Image.save_image(img, icon)
+    interactive(note=Control("C4", all_notes, icons=icon_list))(select_note)
+
+    interactive_pipeline(gui=args.backend, cache=False,
+                         audio=True)(xylo_player)()

requirements.txt

@@ -0,0 +1,2 @@
+interactive-pipe
+wavio

synthetizer.py

@@ -0,0 +1,80 @@
+import numpy as np
+NOTE_FREQUENCIES = {
+    'C4': 261.63,   # Middle C
+    'D4': 293.66,
+    'E4': 329.63,
+    'F4': 349.23,
+    'G4': 392.00,
+    'A4': 440.00,
+    'B4': 493.88,
+    'C5': 523.25
+}
+
+# from pydub import AudioSegment
+# import simpleaudio as sa
+
+
+def generate_sine_wave(frequency, duration, sample_rate=44100, amplitude=0.5):
+    """
+    Generate a sine wave for a given frequency, duration, and sample rate.
+    """
+    t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+    wave = amplitude * np.sin(2 * np.pi * frequency * t)
+    return wave
+
+
+def apply_decay(wave, decay_factor=0.0001):
+    """
+    Apply an exponential decay to the waveform to simulate the damping effect.
+    """
+    decay = np.exp(-decay_factor * np.arange(len(wave)))
+    return wave * decay
+
+
+def create_xylophone_note(frequency, duration=0.5, sample_rate=44100):
+    """
+    Create a synthesized xylophone note using sine waves and damping.
+    """
+    # Generate the fundamental frequency
+    wave = generate_sine_wave(frequency, duration, sample_rate)
+
+    # Add overtones (harmonics) to mimic the xylophone's metallic timbre
+    overtone1 = generate_sine_wave(
+        frequency * 2.5, duration, sample_rate, amplitude=0.3)
+    overtone2 = generate_sine_wave(
+        frequency * 4.0, duration, sample_rate, amplitude=0.2)
+
+    # Combine the fundamental frequency and overtones
+    combined_wave = wave + overtone1 + overtone2
+
+    # Apply decay to simulate the note fading out
+    combined_wave = apply_decay(combined_wave)
+
+    # Normalize to 16-bit range and convert to audio segment
+    # audio_data = (combined_wave * 32767).astype(np.int16)
+    audio_data = combined_wave
+    return audio_data
+    # audio_segment = AudioSegment(audio_data.tobytes(
+    # ), frame_rate=sample_rate, sample_width=2, channels=1)
+
+    # return audio_segment
+
+
+# def play_note(note):
+#     """
+#     Play a given AudioSegment note using simpleaudio.
+#     """
+#     play_obj = sa.play_buffer(
+#         note.raw_data, num_channels=1, bytes_per_sample=2, sample_rate=note.frame_rate)
+#     play_obj.wait_done()
+
+
+def get_note(note: str) -> np.ndarray:
+    # Example usage to create and play a sequence of xylophone notes
+
+    return create_xylophone_note(NOTE_FREQUENCIES.get(note, 'C4'))
+    # Generate and play each note
+    # for note_name, frequency in note_frequencies.items():
+    #     print(f"Playing {note_name}")
+    #     note = create_xylophone_note(frequency)
+    #     play_note(note)