orbwave 0.1.0__py3-none-any.whl

orbwave/__init__.py

@@ -0,0 +1,347 @@
+import sys
+
+if len(sys.argv) < 2:
+    sys.argv.append("audio-visualizer")
+
+import numpy as np
+import soundcard as sc
+import pygame
+import colorsys
+import math
+import random
+import threading
+import queue
+import os
+import sys
+import asyncio
+from orbwave.utils.album_cover import media_art_loop
+
+WIDTH, HEIGHT = 1920, 1200
+FPS = 144
+CHUNK = 1024
+initial_BARS = 128
+RADIUS = 200
+SHAKE_INTENSITY = 5
+BASS_BINS = 6
+PARTICLE_COUNT = 150
+ART_FILE = "current_media_art.png"
+
+
+def _get_loopback_mic():
+
+    all_mics = sc.all_microphones(include_loopback=True)
+
+    try:
+        speaker = sc.default_speaker()
+        speaker_name = speaker.name
+        print(f"[audio] Default speaker: {speaker_name}")
+        for m in all_mics:
+            if "monitor" in m.name.lower() and speaker_name.lower() in m.name.lower():
+                print(f"[audio] ✓ Using monitor of default speaker: {m.name}")
+                return m
+    except Exception as e:
+        print(f"[audio] Could not get default speaker: {e}")
+
+    for m in all_mics:
+        if "monitor" in m.name.lower() or "loopback" in m.name.lower():
+            print(f"[audio] Using monitor source: {m.name}")
+            return m
+
+    mic = sc.default_microphone()
+    print(f"[audio] Falling back to default microphone: {mic.name}")
+    return mic
+
+
+mic = _get_loopback_mic()
+
+audio_queue: queue.Queue = queue.Queue(maxsize=4)
+
+
+def audio_thread_function():
+    """Record audio in a background thread, pushing frames into audio_queue."""
+    try:
+        with mic.recorder(samplerate=44100, blocksize=CHUNK) as rec:
+            while True:
+                data = rec.record(numframes=CHUNK)
+                if audio_queue.full():
+                    try:
+                        audio_queue.get_nowait()
+                    except queue.Empty:
+                        pass
+                audio_queue.put_nowait(data)
+    except Exception as e:
+        print(f"[audio] Recording thread crashed: {e}")
+
+
+def brighten_color(color, min_brightness=100):
+    r, g, b = color
+    brightness = (r + g + b) / 3
+    if brightness < min_brightness:
+        factor = min_brightness / max(1, brightness)
+        r = min(255, int(r * factor))
+        g = min(255, int(g * factor))
+        b = min(255, int(b * factor))
+    return (r, g, b)
+
+
+def start_asyncio_thread():
+    asyncio.run(media_art_loop())
+
+
+def _init_pygame_wayland():
+    if "WAYLAND_DISPLAY" in os.environ:
+        os.environ.setdefault("SDL_VIDEODRIVER", "wayland")
+
+    pygame.init()
+
+    try:
+        screen = pygame.display.set_mode((WIDTH, HEIGHT), pygame.FULLSCREEN)
+    except pygame.error:
+        print("[display] Fullscreen failed, trying borderless window")
+        screen = pygame.display.set_mode((WIDTH, HEIGHT), pygame.NOFRAME)
+
+    pygame.display.set_caption("Audio Visualizer")
+    return screen
+
+
+def run_visualizer():
+
+    media_art_thread = threading.Thread(target=start_asyncio_thread, daemon=True)
+    media_art_thread.start()
+    print("[visual] Media art loop started in a separate thread.")
+
+    screen = _init_pygame_wayland()
+    clock = pygame.time.Clock()
+    pygame.mouse.set_visible(False)
+
+    BARS = initial_BARS
+    hue = 0
+    spectrum_smooth = np.zeros(BARS)
+    center_x, center_y = WIDTH // 2, HEIGHT // 2
+    rotation_angle = 0
+    particles = []
+    current_art = None
+    last_file_mod_time = 0
+    dynamic_radius = 0
+    current_bg_brightness = 10
+    avg_color = (10, 10, 20)
+    palette = [avg_color]
+    loaded_image = None
+
+    for _ in range(PARTICLE_COUNT):
+        particles.append(
+            {
+                "x": random.uniform(0, WIDTH),
+                "y": random.uniform(0, HEIGHT),
+                "size": random.uniform(1, 4),
+                "speed": random.uniform(0.2, 1),
+            }
+        )
+
+    def get_spectrum(audio_data):
+        nonlocal spectrum_smooth
+        mono = audio_data[:, 0] * np.hanning(len(audio_data))
+        fft = np.abs(np.fft.rfft(mono))[:BARS]
+        fft = np.log1p(fft)
+        spectrum_smooth = 0.7 * spectrum_smooth + 0.3 * fft
+        return spectrum_smooth
+
+    audio_thread = threading.Thread(target=audio_thread_function, daemon=True)
+    audio_thread.start()
+
+    running = True
+    while running:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT or (
+                event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
+            ):
+                running = False
+            elif event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_UP:
+                    new_bars = min(BARS * 2, 512)
+                    if new_bars != BARS:
+                        BARS = new_bars
+                        spectrum_smooth = np.zeros(BARS)
+                        print(f"BARS increased to: {BARS}")
+                elif event.key == pygame.K_DOWN:
+                    new_bars = max(BARS // 2, 32)
+                    if new_bars != BARS:
+                        BARS = new_bars
+                        spectrum_smooth = np.zeros(BARS)
+                        print(f"BARS decreased to: {BARS}")
+
+        if os.path.exists(ART_FILE):
+            mod_time = os.path.getmtime(ART_FILE)
+            if mod_time > last_file_mod_time:
+                try:
+                    loaded_image = pygame.image.load(ART_FILE).convert_alpha()
+                    size = int(RADIUS * 1.8)
+                    current_art = pygame.transform.scale(loaded_image, (size, size))
+                    last_file_mod_time = mod_time
+
+                    arr = pygame.surfarray.array3d(loaded_image)  # (w, h, 3)
+                    avg = arr.mean(axis=(0, 1))
+                    avg_color = tuple(int(c) for c in avg)
+
+                    pixels = arr.reshape(-1, 3)
+                    max_samples = 8000
+                    if pixels.shape[0] > max_samples:
+                        step = pixels.shape[0] // max_samples
+                        pixels = pixels[::step]
+
+                    q = (pixels >> 4).astype(np.int32)
+                    keys = (q[:, 0] << 8) + (q[:, 1] << 4) + q[:, 2]
+                    unique, counts = np.unique(keys, return_counts=True)
+
+                    k = 6
+                    palette = []
+                    if unique.size:
+                        top_idx = np.argsort(counts)[-k:]
+                        top_keys = unique[top_idx][::-1]
+                        for key in top_keys:
+                            r = (((key >> 8) & 0xF) << 4) + 8
+                            g = (((key >> 4) & 0xF) << 4) + 8
+                            b = ((key & 0xF) << 4) + 8
+                            if (r + g + b) < 40:
+                                continue
+                            if (r + g + b) > 740:
+                                continue
+                            palette.append((int(r), int(g), int(b)))
+
+                    if not palette:
+                        palette = [avg_color]
+
+                except Exception as e:
+                    print(f"[visual] Error loading image / palette extraction: {e}")
+                    current_art = None
+                    avg_color = (10, 10, 20)
+                    palette = [avg_color]
+        else:
+            current_art = None
+            loaded_image = None
+
+        audio_data = None
+        while not audio_queue.empty():
+            try:
+                audio_data = audio_queue.get_nowait()
+            except queue.Empty:
+                break
+
+        if audio_data is not None:
+            spectrum = get_spectrum(audio_data)
+        else:
+            spectrum = spectrum_smooth
+
+        volume = np.mean(spectrum[:BASS_BINS]) * 0.5
+        dynamic_radius = RADIUS + volume * 25
+        shake_x = shake_y = 0
+
+        target_bg_brightness = 1.0
+        if volume > 1.1:
+            shake_x = random.randint(-SHAKE_INTENSITY, SHAKE_INTENSITY)
+            shake_y = random.randint(-SHAKE_INTENSITY, SHAKE_INTENSITY)
+            target_bg_brightness = 1.0 + volume * 0.5
+
+        current_bg_brightness = current_bg_brightness * 0.9 + target_bg_brightness * 0.1
+
+        darken_factor = 0.35
+        base_r = int(avg_color[0] * darken_factor)
+        base_g = int(avg_color[1] * darken_factor)
+        base_b = int(avg_color[2] * darken_factor)
+        # base_r = int(50 * darken_factor)
+        # base_g = int(50 * darken_factor)
+        # base_b = int(50 * darken_factor)
+
+        r = min(255, int(base_r * current_bg_brightness))
+        g = min(255, int(base_g * current_bg_brightness))
+        b = min(255, int(base_b * current_bg_brightness))
+        screen.fill((r, g, b))
+
+        hue = (hue + 0.002) % 1.0
+        color = tuple(int(c * 255) for c in colorsys.hsv_to_rgb(hue, 1, 1))
+
+        # === Particles ===
+        for p in particles:
+            p["y"] += p["speed"] * (1 + volume * 2)
+            if p["y"] > HEIGHT:
+                p["y"] = 0
+                p["x"] = random.uniform(0, WIDTH)
+            pygame.draw.circle(
+                screen,
+                (255, 255, 255),
+                (int(p["x"] + shake_x * 0.5), int(p["y"] + shake_y * 0.5)),
+                int(p["size"]),
+            )
+
+        half_bars = BARS // 2
+        for i, value in enumerate(spectrum[:half_bars]):
+            if len(palette) == 1:
+                line_color = palette[0]
+            else:
+                t = i / max(1, half_bars - 1)
+                scaled = t * (len(palette) - 1)
+                idx = int(math.floor(scaled))
+                frac = scaled - idx
+                c1 = palette[idx]
+                c2 = palette[min(idx + 1, len(palette) - 1)]
+                line_color = (
+                    int(c1[0] * (1 - frac) + c2[0] * frac),
+                    int(c1[1] * (1 - frac) + c2[1] * frac),
+                    int(c1[2] * (1 - frac) + c2[2] * frac),
+                )
+            line_color = brighten_color(line_color, min_brightness=100)
+
+            angle1 = (2 * math.pi / BARS) * i - math.pi / 2
+            bar_start = dynamic_radius
+            bar_len = dynamic_radius + value * 75
+
+            x1_1 = center_x + math.cos(angle1) * bar_start + shake_x
+            y1_1 = center_y + math.sin(angle1) * bar_start + shake_y
+            x2_1 = center_x + math.cos(angle1) * bar_len + shake_x
+            y2_1 = center_y + math.sin(angle1) * bar_len + shake_y
+            pygame.draw.line(screen, line_color, (x1_1, y1_1), (x2_1, y2_1), 3)
+
+            angle2 = angle1 + math.pi
+            x1_2 = center_x + math.cos(angle2) * bar_start + shake_x
+            y1_2 = center_y + math.sin(angle2) * bar_start + shake_y
+            x2_2 = center_x + math.cos(angle2) * bar_len + shake_x
+            y2_2 = center_y + math.sin(angle2) * bar_len + shake_y
+            pygame.draw.line(screen, line_color, (x1_2, y1_2), (x2_2, y2_2), 3)
+
+        rotation_angle += 0.005
+        if current_art:
+            size = int(dynamic_radius * 1.8)
+            scaled_art = pygame.transform.scale(current_art, (size, size))
+            rotated_art = pygame.transform.rotate(
+                scaled_art, -math.degrees(rotation_angle)
+            )
+            art_rect = rotated_art.get_rect(
+                center=(center_x + shake_x, center_y + shake_y)
+            )
+            screen.blit(rotated_art, art_rect)
+
+        pygame.draw.circle(
+            screen,
+            color,
+            (center_x + shake_x, center_y + shake_y),
+            int(dynamic_radius - 10),
+            2,
+        )
+
+        # === HUD ===
+        font = pygame.font.SysFont(None, 36)
+        text = font.render(f"BARS: {BARS} (UP/DOWN to change)", True, (255, 255, 255))
+        screen.blit(text, (20, 20))
+
+        pygame.display.flip()
+        clock.tick(FPS)
+
+    pygame.quit()
+
+
+def main():
+    run_visualizer()
+
+
+if __name__ == "__main__":
+    run_visualizer()

orbwave/utils/album_cover.py

@@ -0,0 +1,112 @@
+import asyncio
+import os
+from io import BytesIO
+from urllib.parse import unquote
+from urllib.request import urlopen
+
+from jeepney import DBusAddress, new_method_call
+from jeepney.io.blocking import open_dbus_connection
+from PIL import Image, ImageDraw, ImageFilter
+import requests
+
+_BUS = DBusAddress(
+    "/org/freedesktop/DBus",
+    bus_name="org.freedesktop.DBus",
+    interface="org.freedesktop.DBus",
+)
+
+
+def _prop(conn, player, name):
+    addr = DBusAddress(
+        "/org/mpris/MediaPlayer2",
+        bus_name=player,
+        interface="org.freedesktop.DBus.Properties",
+    )
+    msg = new_method_call(addr, "Get", "ss", ("org.mpris.MediaPlayer2.Player", name))
+    return conn.send_and_get_reply(msg, timeout=2).body[0][
+        1
+    ]  # (signature, value) -> value
+
+
+def get_mpris_thumbnail_bytes():
+    try:
+        with open_dbus_connection(bus="SESSION") as conn:
+            names = conn.send_and_get_reply(
+                new_method_call(_BUS, "ListNames"), timeout=2
+            ).body[0]
+            players = [n for n in names if n.startswith("org.mpris.MediaPlayer2.")]
+            if not players:
+                delete_cover()
+                return None
+
+            # предпочитаем плеер, который реально играет
+            player = next(
+                (p for p in players if _prop(conn, p, "PlaybackStatus") == "Playing"),
+                players[0],
+            )
+
+            metadata = _prop(conn, player, "Metadata")
+            art_url = metadata.get("mpris:artUrl", ("s", ""))[1]
+            if not art_url:
+                delete_cover()
+                return None
+
+            if art_url.startswith("file://"):
+                with open(unquote(art_url[7:]), "rb") as f:
+                    return f.read()
+            if art_url.startswith("http"):
+                resp = requests.get(art_url, timeout=5)
+                resp.raise_for_status()
+                return resp.content
+        return None
+    except Exception as e:
+        print(f"[art] could not get cover: {e}")
+        return None
+
+
+def delete_cover():
+    if os.path.exists("current_media_art.png"):
+        os.remove("current_media_art.png")
+
+
+def save_circular_image(data: bytes, path="current_media_art.png"):
+    try:
+        img = Image.open(BytesIO(data))
+
+        if img.mode != "RGBA":
+            img = img.convert("RGBA")
+
+        width, height = img.size
+
+        side = min(width, height)
+        left = (width - side) // 2
+        top = (height - side) // 2
+        img_to_process = img.crop((left, top, left + side, top + side))
+
+        big_size = (side * 4, side * 4)
+        mask = Image.new("L", big_size, 0)
+        draw = ImageDraw.Draw(mask)
+        draw.ellipse((0, 0, big_size[0], big_size[1]), fill=255)
+
+        mask = mask.resize(img_to_process.size, Image.LANCZOS)
+        mask = mask.filter(ImageFilter.SMOOTH)
+
+        circular_img = Image.new("RGBA", img_to_process.size, (0, 0, 0, 0))
+        circular_img.paste(img_to_process, (0, 0), mask)
+
+        circular_img.save(path, "PNG")
+        return True
+
+    except Exception as e:
+        print(f"Error saving image: {e}")
+        return False
+
+
+async def media_art_loop():
+    last_data = None
+    while True:
+        data = get_mpris_thumbnail_bytes()
+        if data and data != last_data:
+            if save_circular_image(data):
+                last_data = data
+        await asyncio.sleep(2.5)

orbwave-0.1.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: orbwave
+Version: 0.1.0
+Summary: Real-time audio visualizer with a spinning album cover
+Keywords: audio,visualizer,pygame,music,spectrum
+Author: rvdxse
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Requires-Dist: jeepney>=0.9.0
+Requires-Dist: numpy>=2.5.4
+Requires-Dist: pillow>=13.0.0
+Requires-Dist: pygame>=2.6.1
+Requires-Dist: requests>=2.34.2
+Requires-Dist: soundcard>=0.4.6
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/<твой-ник>/orbwave
+Description-Content-Type: text/markdown
+
+# orbwave
+
+A fullscreen audio visualizer for Linux built with pygame. It listens to whatever your system is playing and draws a ring of spectrum bars around a spinning album cover.
+
+
+## Features
+
+- Captures system audio (no microphone needed), via the monitor of your default speaker
+- Circular spectrum computed with an FFT; the ring pulses with the bass
+- Rotating circular album cover, taken from the currently playing track
+- Bar colors and background are generated from the cover's palette
+- Bass-reactive screen shake and floating particles
+
+## Requirements
+
+- Linux with PulseAudio or PipeWire (with `pipewire-pulse`)
+- Python 3.12+
+- A media player that exposes MPRIS (Spotify, Firefox, Chromium, VLC, mpv with an MPRIS plugin, etc.) for album covers. Without it, orbwave still works, just without a cover.
+
+## Install
+
+```bash
+pip install orbwave
+```
+
+or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install orbwave
+```
+
+## Usage
+
+```bash
+orbwave
+```
+
+Start any music, and the visualizer reacts to it.
+
+| Key | Action |
+| --- | --- |
+| `Up` | More bars (up to 512) |
+| `Down` | Fewer bars (down to 32) |
+| `Esc` | Quit |
+
+## How it works
+
+1. A background thread records audio in chunks of 1024 samples.
+2. Each chunk gets a Hann window and goes through `numpy.fft.rfft` to get a spectrum.
+3. The spectrum is log-scaled and smoothed, then drawn as bars around a circle.
+4. The lowest bins are averaged into a "bass" value that drives the pulse, shake and particle speed.
+5. Cover art is read from the player over D-Bus (MPRIS), cropped to a circle, and used to pick the color palette.
+
+## Troubleshooting
+
+- **No sound reaction:** check that `pactl list sources short` shows a `.monitor` source and that your default output is the one actually playing.
+- **No album cover:** make sure your player shows up in `playerctl -l` and provides cover art in its metadata.
+
+## Platform support
+
+Linux only for now. Windows and macOS are not supported yet.
+
+## License
+
+[MIT](LICENSE)

orbwave-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+orbwave/__init__.py,sha256=LQlOH7yumMXSs0-5T2AGV9C2KZgs7zGAYhjA_uRpxxs,11715
+orbwave/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orbwave/utils/album_cover.py,sha256=jUcqDVwtwufm-8-Ousx6d9wEkHTiEbV7UfRnwpf693s,3423
+orbwave-0.1.0.dist-info/licenses/LICENSE,sha256=SvHe9aDrmNmk0bFM7-cXO5IAuHORawKCt9HrBIC4QR0,1061
+orbwave-0.1.0.dist-info/WHEEL,sha256=MWx7psoF7KNST9G72pGtiBYuaXRXQXBk9pw5R6FzYko,80
+orbwave-0.1.0.dist-info/entry_points.txt,sha256=wQ8kofQOo1SMY8kcjCKjdSROY6p8lJ8rd4PjcYf3IJQ,42
+orbwave-0.1.0.dist-info/METADATA,sha256=wbypXkFEs--4YFIUz21qUChHGHN9o1M4olOQo_Mi7hA,2689
+orbwave-0.1.0.dist-info/RECORD,,

orbwave-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.7
+Root-Is-Purelib: true
+Tag: py3-none-any

orbwave-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+orbwave = orbwave:main
+

orbwave-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Kyrylo Filchenkov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.