Updates for Retro-Radar.

Now with live ATC audio streaming
using 'Video-LAN' and 'Python-VLC'.

It could be started like:
--------------------
@echo off
setlocal
::
:: Change to suite
::
set PYTHON_VLC_LIB_PATH=f:\ProgramFiler\VideoLan\libvlc.dll
set GNUTLS_DEBUG_LEVEL=
py -3 %~dp0\main.py
--------------------

Author: gvanem

src/externals/Retro-ADSB-radar/README.md

@@ -10,6 +10,7 @@ Aircraft radar display built with Python and Pygame. Visualises real-time aircra
 - Retro colour palette
 - Terminus TTF fonts for an authentic look
 - Default configuration is compatible with the [Hagibis Mini PC USB-C Hub](https://hagibis.com/products-p00288p1.html)
+- Live ATC audio streaming from a specified URL
 
 ![Retro ADS-B Radar Screenshot](screenshot.png)
 
@@ -61,6 +62,10 @@ MIL_PREFIX_LIST = 7CF              # Comma-separated list of military aircraft h
 TAR1090_URL = http://localhost/data/aircraft.json  # tar1090 data source URL
 BLINK_MILITARY = true              # Toggle blinking effect for military aircraft (true/false)
 
+[Audio]
+ATC_STREAM_URL =                   # URL of live ATC audio stream (leave blank to disable)
+AUTO_START = false                 # Start ATC stream automatically (true/false)
+
 [Location]
 LAT = -31.9522                     # Radar centre latitude
 LON = 115.8614                     # Radar centre longitude

src/externals/Retro-ADSB-radar/audio_manager.py

@@ -0,0 +1,92 @@
+class AudioManager:
+    """Manages ATC audio stream playback using a single, persistent VLC instance."""
+    def __init__(self, stream_url: str = None, volume = 100):
+        self.stream_url = stream_url
+        self.player = None
+        self.instance = None
+        self.initialised = False
+        self.volume = volume
+        self.vlc_audio_set_volume = None
+
+    def initialise(self) -> bool:
+        """
+        Initialises the VLC instance and loads the stream.
+        The 'vlc' module is imported here to make it an optional dependency.
+        """
+        if self.initialised:
+            return False  # Already initialised, no need to reinitialise
+
+        if not self.stream_url:
+            return False  # Can't initialise without a stream URL
+
+        try:
+            import vlc
+
+            self.instance = vlc.Instance()
+            self.player = self.instance.media_player_new()
+            media = self.instance.media_new(self.stream_url)
+            media.add_option(':network-caching=10000')
+            media.add_option(':clock-jitter=0')
+            media.add_option(':clock-synchro=0')
+            self.player.set_media(media)
+            self.vlc_audio_set_volume = vlc.libvlc_audio_set_volume
+            self.vlc_audio_set_volume (self.player, self.volume)
+            self.initialised = True
+            print("? Audio manager initialised successfully")
+            return True
+        except ModuleNotFoundError:
+            print("? Error: 'python-vlc' not found. Please install it to use the audio feature.")
+            return False
+        except Exception as e:
+            print(f"? Error initialising audio. Is the VLC application installed? Details: {e}")
+            self.player = None
+            self.instance = None
+            return False
+
+    def toggle(self):
+        """Toggles the audio stream on or off."""
+        if not self.player:
+            return
+
+        if self.player.is_playing():
+            self.player.stop()
+            print("? Audio stream stopped")
+        else:
+            self.player.play()
+            print("? Audio stream started")
+
+    def is_playing(self) -> bool:
+        """Returns True if the audio stream is currently playing."""
+        if not self.player:
+            return False
+        return self.player.is_playing()
+
+    def set_volume(self, delta_volume):
+        if not self.vlc_audio_set_volume:
+           print ("vlc_audio_set_volume == None")
+           return
+
+        if self.volume + delta_volume <= 0:
+           self.volume = 0
+           changed = False
+        elif self.volume + delta_volume >= 100:
+           self.volume = 100
+           changed = False
+        else:
+           self.volume = self.volume + delta_volume
+           self.vlc_audio_set_volume(self.player, self.volume)
+           changed = True
+        print (f"changed: {changed}, delta_volume: {delta_volume}, self.volume: {self.volume}")
+
+    def shutdown(self):
+        """Stops playback and releases VLC resources cleanly."""
+        if self.player:
+            self.player.stop()
+        if self.instance:
+            self.instance.release()
+        self.player = None
+        self.instance = None
+
+        if self.initialised:
+            print("? Audio shut down cleanly")
+

src/externals/Retro-ADSB-radar/config.ini

@@ -1,8 +1,13 @@
 [General]
-FETCH_INTERVAL = 4
+FETCH_INTERVAL  = 4
 MIL_PREFIX_LIST = 7CF
-TAR1090_URL = http://127.0.0.1:8080/data/aircraft.json
-BLINK_MILITARY = true
+TAR1090_URL     = http://127.0.0.1:8080/data/aircraft.json
+BLINK_MILITARY  = true
+
+[Audio]
+ATC_STREAM_URL = https://s1-fmt2.liveatc.net/vhhh5
+ATC_VOLUME     = 70
+AUTO_START     = true
 
 [Location]
 LAT = 60.3045800
@@ -11,7 +16,7 @@ AREA_NAME = Bergen
 RADIUS_NM = 200
 
 [Display]
-SCREEN_WIDTH = 960
+SCREEN_WIDTH  = 960
 SCREEN_HEIGHT = 640
 FPS = 6
 MAX_TABLE_ROWS = 10

src/externals/Retro-ADSB-radar/config.py

@@ -0,0 +1,64 @@
+import configparser
+import os
+
+# Configuration Loading
+config = configparser.ConfigParser()
+script_dir = os.path.dirname (os.path.abspath(__file__)).replace ("\\", "/")
+
+#print (f"script_dir: {script_dir}")
+
+config.read (f"{script_dir}/config.ini")
+
+#
+# General Settings
+#
+FETCH_INTERVAL  = config.getint ('General', 'FETCH_INTERVAL', fallback=10)
+MIL_PREFIX_LIST = [prefix.strip() for prefix in config.get('General', 'MIL_PREFIX_LIST', fallback='7CF').split(',')]
+TAR1090_URL     = config.get ('General', 'TAR1090_URL', fallback='http://localhost/data/aircraft.json')
+BLINK_MILITARY  = config.getboolean ('General', 'BLINK_MILITARY', fallback=True)
+
+#
+# Audio Settings
+#
+ATC_STREAM_URL = config.get('Audio', 'ATC_STREAM_URL', fallback='')
+ATC_VOLUME     = config.getint('Audio', 'ATC_VOLUME', fallback=100)
+ATC_AUTO_START = config.getboolean('Audio', 'AUTO_START', fallback=False)
+
+#
+# Location Settings
+#
+LAT = config.getfloat('Location', 'LAT', fallback=0.0)
+LON = config.getfloat('Location', 'LON', fallback=0.0)
+AREA_NAME = config.get('Location', 'AREA_NAME', fallback='UNKNOWN')
+RADIUS_NM = config.getint('Location', 'RADIUS_NM', fallback=60)
+
+#
+# Display Settings
+#
+SCREEN_WIDTH = config.getint('Display', 'SCREEN_WIDTH', fallback=960)
+SCREEN_HEIGHT = config.getint('Display', 'SCREEN_HEIGHT', fallback=640)
+FPS = config.getint('Display', 'FPS', fallback=6)
+MAX_TABLE_ROWS   = config.getint('Display', 'MAX_TABLE_ROWS', fallback=10)
+FONT_PATH        = config.get('Display', 'FONT_PATH', fallback=f"{script_dir}/fonts/TerminusTTF-4.49.3.ttf")
+BACKGROUND_PATH  = config.get('Display', 'BACKGROUND_PATH', fallback=None)
+TRAIL_MIN_LENGTH = config.getint('Display', 'TRAIL_MIN_LENGTH', fallback=8)
+TRAIL_MAX_LENGTH = config.getint('Display', 'TRAIL_MAX_LENGTH', fallback=25)
+TRAIL_MAX_SPEED  = config.getint('Display', 'TRAIL_MAX_SPEED', fallback=500)
+HEADER_FONT_SIZE = config.getint('Display', 'HEADER_FONT_SIZE', fallback=32)
+RADAR_FONT_SIZE  = config.getint('Display', 'RADAR_FONT_SIZE', fallback=28)
+TABLE_FONT_SIZE  = config.getint('Display', 'TABLE_FONT_SIZE', fallback=28)
+INSTRUCTION_FONT_SIZE = config.getint('Display', 'INSTRUCTION_FONT_SIZE', fallback=28)
+
+if FONT_PATH.startswith("$0"):
+   FONT_PATH = f"{script_dir}/{FONT_PATH[2:]}"
+  # print (f"script_dir: {script_dir}")
+  # print (f"FONT_PATH: {FONT_PATH}")
+
+# Colours
+BLACK = (0, 0, 0)
+GREEN = (0, 255, 0)
+BRIGHT_GREEN = (50, 255, 50)
+DIM_GREEN = (0, 180, 0)
+RED = (255, 50, 50)
+YELLOW = (255, 255, 0)
+AMBER = (255, 191, 0)

src/externals/Retro-ADSB-radar/data_fetcher.py

@@ -0,0 +1,50 @@
+import requests
+import threading
+import time
+from typing import List
+
+import config
+from data_models import Aircraft
+
+class AircraftTracker:
+    """Handles fetching aircraft data from tar1090"""
+    def __init__(self):
+        self.aircraft: List[Aircraft] = []
+        self.status = "INITIALISING"
+        self.last_update = time.time()
+        self.running = True
+
+    def fetch_data(self) -> List[Aircraft]:
+        """Fetch aircraft from local tar1090"""
+        try:
+          # print(f"Fetching aircraft data from {config.TAR1090_URL}...")
+            response = requests.get(config.TAR1090_URL, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            aircraft_list = []
+            for ac_data in data.get('aircraft', []):
+                ac = Aircraft.from_dict(ac_data)
+                if ac:
+                    aircraft_list.append(ac)
+            print(f"? Found {len(aircraft_list)} aircraft within {config.RADIUS_NM}NM range")
+            return aircraft_list
+        except requests.RequestException as e:
+            if 0:
+               print(f"? Error: Couldn't fetch aircraft data: {e}")
+            else:
+               print("Couldn't fetch aircraft data")
+            return []
+
+    def update_loop(self):
+        """Background thread to fetch data periodically"""
+        while self.running:
+            self.status = "SCANNING"
+            self.last_update = time.time()
+            self.aircraft = self.fetch_data()
+            self.status = "ACTIVE" if self.aircraft else "NO CONTACTS"
+            time.sleep(config.FETCH_INTERVAL)
+
+    def start(self):
+        """Start the background data fetching"""
+        thread = threading.Thread(target=self.update_loop, daemon=True)
+        thread.start()

src/externals/Retro-ADSB-radar/data_models.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+import config
+from utils import calculate_distance_bearing
+
+@dataclass
+class Aircraft:
+    """Aircraft data from tar1090"""
+    hex_code: str
+    callsign: str
+    lat: float
+    lon: float
+    altitude: int
+    speed: int
+    track: float
+    distance: float
+    bearing: float
+    is_military: bool = False
+
+    @staticmethod
+    def from_dict(data: dict) -> Optional[Aircraft]:
+        """Create an Aircraft object from a dictionary."""
+        if 'lat' not in data or 'lon' not in data:
+            return None
+        lat, lon = data['lat'], data['lon']
+        distance, bearing = calculate_distance_bearing(config.LAT, config.LON, lat, lon)
+        if distance > config.RADIUS_NM:
+            return None
+        hex_code = data['hex'].lower()
+        mil_prefixes = tuple(prefix.lower() for prefix in config.MIL_PREFIX_LIST)
+        is_military = hex_code.startswith(mil_prefixes)
+        return Aircraft(
+            hex_code=hex_code,
+            callsign=data.get('flight', 'UNKNOWN').strip()[:8],
+            lat=lat, lon=lon,
+            altitude=data.get('alt_baro', 0) or 0,
+            speed=int(data.get('gs', 0) or 0),
+            track=data.get('track', 0) or 0,
+            distance=distance, bearing=bearing,
+            is_military=is_military
+        )