avm/hassio-addons
1
0
Fork 0
mirror of https://github.com/alexbelgium/hassio-addons.git synced 2026-06-02 05:44:03 +02:00
Code Issues Packages Projects Releases Wiki Activity

Update DOCS.md

Browse Source
This commit is contained in:
Alexandre
2024-10-17 09:46:07 +02:00
committed by GitHub
parent c446d7359c
commit 7057bc0af7
1 changed files with 68 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

232
birdnet-pi/DOCS.md
View File

@@ -84,7 +84,7 @@ sudo ethtool -s eth0 speed 100 duplex full autoneg on
# Run GStreamer RTSP server if installed # Run GStreamer RTSP server if installed
if command -v gst-launch-1.0 &>/dev/null; then if command -v gst-launch-1.0 &>/dev/null; then
./rtsp_audio_server.py --device plughw:0,0 --format S16LE --rate 96000 --channels 2 --mount-point /birdmic --port 8554 >/tmp/log_rtsp 2>/tmp/log_rtsp_error & ./rtsp_audio_server.py & sleep 2 >/tmp/log_rtsp 2>/tmp/log_rtsp_error &
gst_pid=$! gst_pid=$!
else else
echo "GStreamer not found, skipping to ffmpeg fallback" echo "GStreamer not found, skipping to ffmpeg fallback"
@@ -155,11 +155,11 @@ Create a script named rtsp_audio_server.py
``` ```
#!/usr/bin/env python3 #!/usr/bin/env python3
import sys
import gi import gi
import argparse import sys
import socket
import logging import logging
import os
import signal
gi.require_version('Gst', '1.0') gi.require_version('Gst', '1.0')
gi.require_version('GstRtspServer', '1.0') gi.require_version('GstRtspServer', '1.0')
@@ -169,189 +169,93 @@ from gi.repository import Gst, GstRtspServer, GLib
# Initialize GStreamer # Initialize GStreamer
Gst.init(None) Gst.init(None)
def get_lan_ip(): # Configure Logging
""" LOG_FILE = "gst_rtsp_server.log"
Retrieves the LAN IP address by creating a dummy connection. logging.basicConfig(
""" filename=LOG_FILE,
try: filemode='a',
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: format='%(asctime)s %(levelname)s: %(message)s',
# This doesn't send any data; it's just used to get the local IP address level=logging.DEBUG # Set to DEBUG for comprehensive logging
s.connect(("8.8.8.8", 80)) )
return s.getsockname()[0] logger = logging.getLogger(__name__)
except Exception as e:
logging.error(f"Failed to get LAN IP address: {e}")
return "127.0.0.1"
class PCMStream(GstRtspServer.RTSPMediaFactory): class AudioFactory(GstRtspServer.RTSPMediaFactory):
def __init__(self, device, format, rate, channels): def __init__(self):
super(PCMStream, self).__init__() super(AudioFactory, self).__init__()
self.device = device self.set_shared(True) # Allow multiple clients to access the stream
self.format = format self.set_latency(500) # Increase latency to 500ms to improve stream stability
self.rate = rate self.set_suspend_mode(GstRtspServer.RTSPSuspendMode.NONE) # Prevent suspension of the stream when no clients are connected
self.channels = channels logger.debug("AudioFactory initialized: shared=True, latency=500ms, suspend_mode=NONE.")
self.set_shared(True)
def do_create_element(self, url): def do_create_element(self, url):
""" """
Overridden method to create the GStreamer pipeline. Create and return the GStreamer pipeline for streaming audio.
""" """
# Attempt to retrieve and log the RTSP URL's URI
try:
# Some versions might have 'get_uri()', others might not
uri = url.get_uri()
logging.info(f"Creating pipeline for URL: {uri}")
except AttributeError:
# Fallback if 'get_uri()' doesn't exist
logging.info("Creating pipeline for RTSP stream.")
# Define the GStreamer pipeline string for PCM streaming
pipeline_str = ( pipeline_str = (
f"alsasrc device={self.device} ! " "alsasrc device=plughw:0,0 do-timestamp=true buffer-time=2000000 latency-time=1000000 ! " # Increased buffer size
f"audio/x-raw, format={self.format}, rate={self.rate}, channels={self.channels} ! " "queue max-size-buffers=0 max-size-bytes=0 max-size-time=0 ! " # Add queue to handle buffer management
"audioconvert ! audioresample ! " "audioconvert ! " # Convert audio to a suitable format
"rtpL16pay name=pay0 pt=96" "audioresample ! " # Resample audio if necessary
"audio/x-raw,format=S16BE,channels=2,rate=48000 ! " # Set audio properties (rate = 48kHz)
"rtpL16pay name=pay0 pt=96" # Payload for RTP
) )
logger.debug(f"Creating GStreamer pipeline: {pipeline_str}")
logging.info(f"Pipeline: {pipeline_str}") try:
pipeline = Gst.parse_launch(pipeline_str)
# Parse and launch the pipeline if not pipeline:
pipeline = Gst.parse_launch(pipeline_str) logger.error("Failed to parse GStreamer pipeline.")
return None
if not pipeline: return pipeline
logging.error("Failed to create GStreamer pipeline.") except Exception as e:
logger.error(f"Exception while creating pipeline: {e}")
return None return None
# Get the bus from the pipeline and connect to the message handler
bus = pipeline.get_bus()
bus.add_signal_watch()
bus.connect("message", self.on_message)
return pipeline
def on_message(self, bus, message):
t = message.type
if t == Gst.MessageType.ERROR:
err, debug = message.parse_error()
logging.error(f"GStreamer Error: {err}, {debug}")
elif t == Gst.MessageType.WARNING:
err, debug = message.parse_warning()
logging.warning(f"GStreamer Warning: {err}, {debug}")
elif t == Gst.MessageType.EOS:
logging.info("End-Of-Stream reached.")
return True
class GstServer: class GstServer:
def __init__(self, mount_point, device, format, rate, channels, port, ip=None): def __init__(self):
self.mount_point = mount_point
self.device = device
self.format = format
self.rate = rate
self.channels = channels
self.port = port
self.ip = ip
self.server = GstRtspServer.RTSPServer() self.server = GstRtspServer.RTSPServer()
self.server.set_service(str(self.port)) self.server.set_service("8554") # Set the RTSP server port
self.server.set_address("0.0.0.0") # Listen on all network interfaces
logger.debug("RTSP server configured: address=0.0.0.0, port=8554.")
if self.ip: factory = AudioFactory()
self.server.set_address(self.ip) mount_points = self.server.get_mount_points()
else: mount_points.add_factory("/birdmic", factory) # Mount point
self.server.set_address("0.0.0.0") logger.debug("Factory mounted at /birdmic.")
self.factory = PCMStream(self.device, self.format, self.rate, self.channels) self.server.attach(None) # Attach the server to the default main context
self.mount_points = self.server.get_mount_points() logger.info("RTSP server attached and running.")
self.mount_points.add_factory(self.mount_point, self.factory)
try:
self.server.attach(None)
except Exception as e:
logging.error(f"Failed to attach RTSP server: {e}")
sys.exit(1)
server_ip = self.ip if self.ip else get_lan_ip()
# Verify that the server is listening on the desired port
if not self.verify_server_binding():
logging.error(f"RTSP server failed to bind to port {self.port}. It might already be in use.")
sys.exit(1)
print(f"RTSP server is live at rtsp://{server_ip}:{self.port}{self.mount_point}")
def verify_server_binding(self):
"""
Verifies if the RTSP server is successfully listening on the specified port.
"""
try:
with socket.create_connection(("127.0.0.1", self.port), timeout=2):
return True
except Exception as e:
logging.error(f"Verification failed: {e}")
return False
def parse_args():
parser = argparse.ArgumentParser(description="GStreamer RTSP Server for 16-bit PCM Audio")
parser.add_argument(
'--device', type=str, default='plughw:0,0',
help='ALSA device to capture audio from (default: plughw:0,0)'
)
parser.add_argument(
'--format', type=str, default='S16LE',
help='Audio format (default: S16LE)'
)
parser.add_argument(
'--rate', type=int, default=44100,
help='Sampling rate in Hz (default: 44100)'
)
parser.add_argument(
'--channels', type=int, default=1,
help='Number of audio channels (default: 1)'
)
parser.add_argument(
'--mount-point', type=str, default='/birdmic',
help='RTSP mount point (default: /birdmic)'
)
parser.add_argument(
'--port', type=int, default=8554,
help='RTSP server port (default: 8554)'
)
parser.add_argument(
'--ip', type=str, default=None,
help='Explicit LAN IP address to bind the RTSP server to (default: auto-detected)'
)
return parser.parse_args()
def main(): def main():
# Configure logging to display errors and warnings # Create GstServer instance
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') server = GstServer()
print("RTSP server is running at rtsp://localhost:8554/birdmic")
args = parse_args() logger.info("RTSP server is running at rtsp://localhost:8554/birdmic")
try:
server = GstServer(
mount_point=args.mount_point,
device=args.device,
format=args.format,
rate=args.rate,
channels=args.channels,
port=args.port,
ip=args.ip
)
except Exception as e:
logging.error(f"Failed to initialize RTSP server: {e}")
sys.exit(1)
# Set up the main loop with proper logging
loop = GLib.MainLoop() loop = GLib.MainLoop()
# Handle termination signals to ensure graceful shutdown
def shutdown(signum, frame):
logger.info(f"Shutting down RTSP server due to signal {signum}.")
print("\nShutting down RTSP server.")
loop.quit()
# Register signal handlers for graceful termination
signal.signal(signal.SIGINT, shutdown)
signal.signal(signal.SIGTERM, shutdown)
try: try:
loop.run() loop.run()
except KeyboardInterrupt:
print("Shutting down RTSP server...")
loop.quit()
except Exception as e: except Exception as e:
logging.error(f"An unexpected error occurred: {e}") logger.error(f"Main loop encountered an exception: {e}")
loop.quit() finally:
logger.info("RTSP server has been shut down.")
if __name__ == "__main__": if __name__ == "__main__":
# Ensure log file exists
if not os.path.exists(LOG_FILE):
open(LOG_FILE, 'w').close()
main() main()
``` ```