go2rtc
v1.9.7 - 2024-11-11
Application de streaming de caméra ultime avec prise en charge RTSP, WebRTC, HomeKit, FFmpeg, RTMP, etc.
Petite application sans dépendance et sans configuration pour tous les systèmes d'exploitation (Windows, macOS, Linux, ARM)
délai zéro pour de nombreux protocoles pris en charge (latence de streaming la plus faible possible)
streaming depuis RTSP, RTMP, DVRIP, HTTP (FLV/MJPEG/JPEG/TS), caméras USB et autres sources
streaming à partir de n'importe quelle source, pris en charge par FFmpeg
streaming vers RTSP, WebRTC, MSE/MP4, HomeKit HLS ou MJPEG
publier n'importe quelle source sur des services de streaming populaires (YouTube, Telegram, etc.)
premier projet au monde prenant en charge le streaming à partir des caméras HomeKit
prend en charge H265 pour WebRTC dans le navigateur (Safari uniquement, en savoir plus)
transcodage à la volée pour les codecs non pris en charge via FFmpeg
lire des fichiers audio et des flux en direct sur certaines caméras avec haut-parleur
négociation de codecs bidirectionnels multi-sources
mélanger des pistes de différentes sources en un seul flux
correspondance automatique des codecs pris en charge par le client
Audio bidirectionnel pour certaines caméras
streaming depuis des réseaux privés via ngrok
peut être intégré à n'importe quelle plateforme de maison intelligente ou être utilisé comme application autonome
Inspiré par :
série de projets en streaming de @deepch
bibliothèque webrtc go et toute l'équipe @pion
idée de serveur rtsp-simple de @aler9
Idée de pipeline de framework GStreamer
Idée de routage du framework MediaSoup
Protocole d'accessoires HomeKit de @brutella
créateur du logo du projet @v_novoseltsev
Démarrage rapide
go2rtc : binaire
go2rtc : Docker
go2rtc : module complémentaire Home Assistant
go2rtc : intégration de Home Assistant
go2rtc : version de développement
Configuration
Audio bidirectionnel
Source : RTSP
Source : RTMP
Source : HTTP
Source : ONVIF
Source : FFmpeg
Source : appareil FFmpeg
Source : Exécutif
Source : Écho
Source : Expr
Source : HomeKit
Source : Bulle
Source : DVRIP
Source : Tapo
Source : Kasa
Source : GoPro
Source : Ivideon
Source : Hass
Source : ISAPI
Source : Nid
Source : Roborock
Source : WebRTC
Source : WebTorrent
Sources entrantes
Diffusion vers la caméra
Publier le flux
Module : Flux
Module : API
Module : RTSP
Module : RTMP
Module : WebRTC
Module : HomeKit
Module : WebTorrent
Module : ngrok
Module : Hass
Module : MP4
Module : HLS
Module : MJPEG
Module : Journal
Sécurité
Filtres de codecs
La folie des codecs
Négociation des codecs
Projets utilisant go2rtc
Expérience de caméra
CONSEILS
FAQ
Téléchargez le binaire ou utilisez le module complémentaire ou l'intégration Docker ou Home Assistant
Interface Web ouverte : http://localhost:1984/
En option :
ajoutez vos flux au fichier de configuration
configurer l'accès externe à webrtc
Développeurs :
écrivez votre propre interface Web
intégrez l'API Web dans votre plateforme de maison intelligente
Téléchargez le binaire pour votre système d'exploitation à partir de la dernière version :
go2rtc_win64.zip - Windows 10+ 64 bits
go2rtc_win32.zip - Windows 7+ 32 bits
go2rtc_win_arm64.zip - Windows ARM 64 bits
go2rtc_linux_amd64 - Linux 64 bits
go2rtc_linux_i386 - Linux 32 bits
go2rtc_linux_arm64 - Linux ARM 64 bits (ex. Système d'exploitation Raspberry 64 bits)
go2rtc_linux_arm - Linux ARM 32 bits (ex. Raspberry 32 bits)
go2rtc_linux_armv6 - Linux ARMv6 (pour les anciens Raspberry 1 et Zero)
go2rtc_linux_mipsel - Linux MIPS (ex. Xiaomi Gateway 3, caméras Wyze)
go2rtc_mac_amd64.zip - macOS 10.13+ Intel 64 bits
go2rtc_mac_arm64.zip - macOS ARM 64 bits
N'oubliez pas de corriger les droits chmod +x go2rtc_xxx_xxx sous Linux et Mac.
Le conteneur Docker alexxit/go2rtc prend en charge plusieurs architectures, notamment amd64 , 386 , arm64 et arm . Ce conteneur offre les mêmes fonctionnalités que le module complémentaire Home Assistant mais est conçu pour fonctionner indépendamment de Home Assistant. Il est préinstallé avec FFmpeg, ngrok et Python.
Installer le module complémentaire :
Paramètres > Modules complémentaires > Plus > Dépôts > Ajouter https://github.com/AlexxIT/hassio-addons
go2rtc > Installer > Démarrer
Intégration de la configuration
Le composant personnalisé WebRTC Camera peut être utilisé sur n’importe quelle installation de Home Assistant, y compris HassWP sous Windows. Il peut automatiquement télécharger et utiliser la dernière version de go2rtc. Ou il peut se connecter à une version existante de go2rtc. L'installation du module complémentaire dans ce cas est facultative.
Dernière version, mais peut-être instable :
Binaire : dernière version nocturne
Docker : alexxit/go2rtc:master ou alexxit/go2rtc:master-hardware versions
Module complémentaire Hass : versions matérielles go2rtc master ou go2rtc master hardware
par défaut, go2rtc recherchera go2rtc.yaml dans le répertoire de travail actuel
Le serveur api démarrera sur le port 1984 par défaut (TCP)
Le serveur rtsp démarrera sur le port 8554 par défaut (TCP)
webrtc utilisera le port 8555 (TCP/UDP) pour les connexions
ffmpeg utilisera les options de transcodage par défaut
Les options de configuration et une liste complète des paramètres peuvent être trouvées dans le wiki.
Modules disponibles :
flux
api - API HTTP (important pour le support WebRTC)
rtsp - Serveur RTSP (important pour la prise en charge de FFmpeg)
webrtc - Serveur WebRTC
mp4 - MSE, flux MP4 et serveur d'instantanés MP4
hls - Serveur de flux HLS TS ou fMP4
mjpeg - Serveur MJPEG
ffmpeg - Intégration FFmpeg
ngrok - intégration ngrok (accès externe pour réseau privé)
hass - Intégration de Home Assistant
log - configuration des journaux
go2rtc prend en charge différents types de sources de flux. Vous pouvez configurer un ou plusieurs liens de n'importe quel type comme source de flux.
Types de sources disponibles :
rtsp - Caméras RTSP et RTSPS avec prise en charge audio bidirectionnelle
rtmp - Flux RTMP
http - HTTP-FLV , MPEG-TS , JPEG (instantanés), flux MJPEG
onvif - obtient le lien RTSP de la caméra et le lien d'instantané en utilisant le protocole ONVIF
ffmpeg - Intégration FFmpeg ( HLS , files et bien d'autres)
ffmpeg:device - caméra ou webcam USB locale
exec - récupère le média à partir de la sortie d'une application externe
echo - obtenir le lien de flux depuis bash ou python
expr - obtenir le lien de flux via le langage d'expression intégré
homekit - diffusion depuis la caméra HomeKit
bulle - streaming depuis ESeeCloud/dvr163 NVR
dvrip - streaming depuis DVR-IP NVR
tapo - Caméras TP-Link Tapo avec prise en charge audio bidirectionnelle
Kasa - Caméras TP-Link Kasa
gopro - Caméras GoPro
ivideon - caméras publiques du service Ivideon
hass - Intégration de Home Assistant
isapi - audio bidirectionnel pour les caméras Hikvision (ISAPI)
roborock - Aspirateurs Roborock avec caméras
webrtc - Sources WebRTC/WHEP
webtorrent - Source WebTorrent d'un autre go2rtc
En savoir plus sur les sources entrantes
Pris en charge pour les sources :
Caméras RTSP avec profil ONVIF T (connexion par canal arrière)
Caméras DVRIP
Caméras TP-Link Tapo
Caméras Hikvision ISAPI
Modèles d'aspirateurs Roborock avec caméras
Exécuter l'audio sur le serveur
N'importe quel navigateur comme caméra IP
L'audio bidirectionnel peut être utilisé dans le navigateur avec la technologie WebRTC. Le navigateur donnera accès au microphone uniquement pour les sites HTTPS (en savoir plus).
go2rtc prend également en charge la lecture de fichiers audio et les flux en direct sur ces caméras.
flux : sonoff_camera : rtsp://rtsp:[email protected]/av_stream/ch0 dahua_camera : - rtsp://admin:[email protected]/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif- rtsp://admin:[email protected]/cam/realmonitor?channel=1&subtype=1 amcrest_doorbell : - rtsp://username:[email protected]:554/cam/realmonitor?channel=1&subtype=0#backchannel=0 unifi_camera : rtspx://192.168.1.123:7441/fD6ouM72bWoFijxK glichy_camera : ffmpeg:rtsp://username:[email protected]/live/ch00_1
Recommandations
Les utilisateurs d'Amcrest Doorbell souhaiteront peut-être désactiver l'audio bidirectionnel, car avec un flux actif, aucun bouton d'appel ne fonctionnera. Vous devez ajouter #backchannel=0 à la fin de votre lien RTSP dans le fichier de configuration YAML
Les utilisateurs de Dahua Doorbell voudront peut-être modifier le codec audio du canal arrière
Les utilisateurs de Reolink voudront peut-être NE PAS utiliser le protocole RTSP du tout, certains modèles de caméras ont une implémentation de flux très horrible et inutilisable.
Les utilisateurs d'Ubiquiti UniFi voudront peut-être désactiver la vérification HTTPS. Utilisez le préfixe rtspx:// au lieu de rtsps:// . Et n'utilisez pas le suffixe ?enableSrtp
Les utilisateurs de TP-Link Tapo peuvent ignorer la connexion et le mot de passe, car go2rtc prend en charge la connexion sans eux.
Si votre caméra dispose de deux liens RTSP, vous pouvez les ajouter tous les deux comme sources. Ceci est utile lorsque les flux ont des codecs différents, par exemple l'audio AAC avec le flux principal et l'audio PCMU/PCMA avec le deuxième flux.
Si le flux de votre caméra présente des problèmes, essayez d'utiliser la source ffmpeg. Cela n'ajoutera pas de charge CPU si vous n'utilisez pas le transcodage
Si le flux de votre caméra est très problématique, essayez d'utiliser le transcodage avec la source ffmpeg
Autres options
Format : rtsp...#{param1}#{param2}#{param3}
Ajouter un délai d'attente personnalisé #timeout=30 (en secondes)
Ignorer l'audio - #media=video ou ignorer la vidéo - #media=audio
Ignorer l'API audio bidirectionnelle #backchannel=0 - important pour certaines caméras problématiques
Utilisez le transport WebSocket #transport=ws...
RTSP sur WebSocket
streams : # WebSocket avec autorisation, RTSP - sans axe-rtsp-ws : rtsp://192.168.1.123:4567/axis-media/media.amp?overview=0&camera=1&resolution=1280x720&videoframeskipmode=empty&Axis-Orig-Sw=true#transport=ws://user:[email protected]:4567/ rtsp-sur-websocket # WebSocket sans autorisation, RTSP - avec dahua-rtsp-ws : rtsp://user:[email protected]/cam/realmonitor?channel=1&subtype=1&proto=Private3#transport=ws://192.168.1.123/rtspoverwebsocket
Vous pouvez obtenir du flux à partir du serveur RTMP, par exemple Nginx avec nginx-rtmp-module.
flux : rtmp_stream : rtmp://192.168.1.123/live/camera1
Type de contenu pris en charge :
HTTP-FLV ( video/x-flv ) - identique à RTMP, mais via HTTP
HTTP-JPEG ( image/jpeg ) - lien d'instantané de caméra, peut être converti par go2rtc en flux MJPEG
HTTP-MJPEG ( multipart/x ) - flux MJPEG simple sur HTTP
MPEG-TS ( video/mpeg ) - format de streaming existant
Source prend également en charge les flux HTTP et TCP avec détection automatique pour différents formats : MJPEG , flux binaire H.264/H.265 , MPEG-TS .
flux : # flux [HTTP-FLV] au format vidéo/x-flv
http_flv : http://192.168.1.123:20880/api/camera/stream/780900131155/657617
# Les instantanés [JPEG] de la caméra Dahua seront convertis en flux MJPEG
dahua_snap : http://admin:[email protected]/cgi-bin/snapshot.cgi?channel=1
# Le flux [MJPEG] sera proxy sans modification
http_mjpeg : https://mjpeg.sanford.io/count.mjpeg
# [Stream binaire MJPEG ou H.264/H.265 ou MPEG-TS]
tcp_magic : tcp://192.168.1.123:12345
# Ajouter un en-tête personnalisé
custom_header : "https://mjpeg.sanford.io/count.mjpeg#header=Authorization : Bearer XXX"PS. La caméra Dahua a un bug : si vous sélectionnez le codec MJPEG pour le deuxième flux RTSP, l'instantané ne fonctionnera pas.
Nouveau dans la v1.5.0
La source n'est pas très utile si vous connaissez déjà les liens RTSP et instantanés pour votre caméra. Mais cela peut être utile si vous ne le faites pas.
WebUI > Ajouter la prise en charge de pages Web pour la découverte automatique ONVIF. Votre serveur doit être sur le même sous-réseau que la caméra. Si vous utilisez Docker, vous devez utiliser « hôte réseau ».
flux : dahua1 : onvif://admin:[email protected] reolink1 : onvif://admin:[email protected]:8000 tapo1 : onvif://admin:[email protected]:2020
Vous pouvez obtenir n'importe quel flux, fichier ou appareil via FFmpeg et le pousser vers go2rtc. L'application démarrera automatiquement FFmpeg avec les arguments appropriés lorsque quelqu'un commencera à regarder le flux.
FFmpeg préinstallé pour les utilisateurs de Docker et Hass Add-on
Les utilisateurs du module complémentaire Hass peuvent cibler les fichiers du dossier /media
Format : ffmpeg:{input}#{param1}#{param2}#{param3} . Exemples :
streams : # [FILE] toutes les pistes seront copiées sans codecs de transcodage fichier1 : ffmpeg:/media/BigBuckBunny.mp4 # La vidéo [FILE] sera transcodée en H264, l'audio sera ignoré fichier2 : ffmpeg:/media/BigBuckBunny.mp4#video=h264 # La vidéo [FILE] sera copiée, l'audio sera transcodé en pcmu fichier3 : ffmpeg:/media/BigBuckBunny.mp4#video=copy#audio=pcmu # La vidéo [HLS] sera copiée, l'audio sera ignoré hls : ffmpeg :https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear5/prog_index.m3u8#video=copy # La vidéo [MJPEG] sera transcodée en H264 mjpeg : ffmpeg :http://185.97.122.128/cgi-bin/faststream.jpg#video=h264 # La vidéo [RTSP] avec rotation doit être transcodée, sélectionnez donc H264 faire pivoter : ffmpeg:rtsp://rtsp:[email protected]/av_stream/ch0#video=h264#rotate=90
Tous les formats de trascodage ont des modèles intégrés : h264 , h265 , opus , pcmu , pcmu/16000 , pcmu/48000 , pcma , pcma/16000 , pcma/48000 , aac , aac/16000 .
Mais vous pouvez les remplacer via la configuration YAML. Vous pouvez également ajouter vos propres formats à configurer et les utiliser avec les paramètres source.
ffmpeg : bin : ffmpeg # chemin vers le binaire ffmpeg
h264 : "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zérolatence -profile:v main -level:v 4.1"
mycodec : "-tous les arguments pris en charge par ffmpeg..."
mon entrée : "-fflags nobuffer -flags low_delay -timeout 5000000 -i {input}"
monraw : "-ss 00:00:20" Vous pouvez utiliser le nom du flux go2rtc comme entrée ffmpeg (ex. ffmpeg:camera1#video=h264 )
Vous pouvez utiliser les paramètres video et audio plusieurs fois (ex. #video=copy#audio=copy#audio=pcmu )
Vous pouvez utiliser le paramètre rotate avec des valeurs de 90 , 180 , 270 ou -90 , ce qui est important pour le transcodage (ex. #video=h264#rotate=90 )
Vous pouvez utiliser des paramètres width et/ou height , importants pour le transcodage (ex. #video=h264#width=1280 )
Vous pouvez utiliser drawtext pour ajouter un horodatage (ex. drawtext=x=2:y=2:fontsize=12:fontcolor=white:box=1:boxcolor=black )
Cela augmentera considérablement le CPU du serveur, même avec une accélération matérielle
Vous pouvez utiliser le paramètre raw pour tout argument FFmpeg supplémentaire (ex. #raw=-vf transpose=1 )
Vous pouvez utiliser le paramètre input pour remplacer le modèle d'entrée par défaut (ex. #input=rtsp/udp changera le transport RTSP de TCP à UDP+TCP)
Vous pouvez utiliser une valeur d'entrée brute (ex. #input=-timeout 5000000 -i {input} )
Vous pouvez ajouter vos propres modèles de saisie
En savoir plus sur l'accélération matérielle.
PS. Il est recommandé de vérifier le matériel disponible sur la page d'ajout de WebUI.
Vous pouvez obtenir des vidéos à partir de n'importe quelle caméra USB ou webcam sous forme de flux RTSP ou WebRTC. Cela fait partie de l'intégration FFmpeg.
vérifier les appareils disponibles dans l'interface Web
video_size et framerate doivent être pris en charge par votre caméra !
pour Linux, seule la vidéo est prise en charge pour l'instant
pour macOS, vous pouvez diffuser la caméra Facetime ou l'intégralité du bureau !
pour macOS, il est important de définir le bon framerate
Format : ffmpeg:device?{input-params}#{param1}#{param2}#{param3}
flux : linux_usbcam : ffmpeg:device?video=0&video_size=1280x720#video=h264 windows_webcam : ffmpeg:device?video=0#video=h264 macos_facetime : ffmpeg:device?video=0&audio=1&video_size=1280x720&framerate=30#video=h264#audio=pcma
PS. Il est recommandé de vérifier les appareils disponibles sur la page d'ajout de WebUI.
La source Exec peut exécuter n’importe quelle application externe et en attendre des données. Deux transports sont pris en charge : pipe ( à partir de la v1.5.0 ) et RTSP .
Si vous souhaitez utiliser le transport RTSP , la commande doit contenir l'argument {output} à n'importe quel endroit. Au lancement, elle sera remplacée par l'adresse locale du serveur RTSP.
pipe lit les données de la sortie standard de l'application dans différents formats : MJPEG , H.264/H.265 bitstream , MPEG-TS . Pipe peut également écrire des données sur l'application stdin dans deux formats : PCMA et PCM/48000 .
La source peut être utilisée avec :
FFmpeg - go2rtc ffmpeg source juste un raccourci vers la source d'exécution
FFplay - jouez de l'audio sur votre serveur
GStreamer
Caméras Raspberry Pi
n'importe quel votre propre logiciel
Les commandes de canal prennent en charge les paramètres (format : exec:{command}#{param1}#{param2} ) :
killsignal - signal qui sera envoyé pour arrêter le processus (forme numérique)
killtimeout - temps en secondes pour l'arrêt forcé avec sigkill
backchannel - activer le canal arrière pour l'audio bidirectionnel
flux : flux : exec:ffmpeg -re -i /media/BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp {output}
picam_h264 : exec:libcamera-vid -t 0 --inline -o -
picam_mjpeg : exec:libcamera-vid -t 0 --codec mjpeg -o -
pi5cam_h264 : exec:libcamera-vid -t 0 --libav-format h264 -o -
canon : exec:gphoto2 --capture-movie --stdout#killsignal=2#killtimeout=5
play_pcma : exec:ffplay -fflags nobuffer -f alaw -ar 8000 -i -#backchannel=1
play_pcm48k : exec:ffplay -fflags nobuffer -f s16be -ar 48000 -i -#backchannel=1Certaines sources peuvent avoir un lien dynamique. Et vous devrez l'obtenir à l'aide d'un script bash ou python. Votre script doit faire écho à un lien vers la source. RTSP, FFmpeg ou l'une des sources prises en charge.
Les utilisateurs de Docker et Hass Add-on ont préinstallé python3 , curl , jq .
Vérifiez les exemples dans le wiki.
flux : apple_hls : echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html
Nouveau dans la v1.8.2
Comme la source echo , mais utilise le langage d'expression expr intégré (en savoir plus).
Important:
Vous pouvez utiliser les caméras HomeKit sans appareils Apple (iPhone, iPad, etc.), c'est juste un autre protocole
L'appareil HomeKit ne peut être associé qu'à un seul écosystème. Donc, si vous l'avez couplé à un iPhone (Apple Home), vous ne pouvez pas le coupler avec Home Assistant ou go2rtc. Ou si vous l'avez couplé à go2rtc, vous ne pouvez pas le coupler avec un iPhone.
L'appareil HomeKit doit être sur le même réseau avec un mDNS fonctionnel entre l'appareil et go2rtc
go2rtc prend en charge l'importation d'appareils HomeKit couplés depuis Home Assistant. Vous pouvez donc utiliser la caméra HomeKit avec Hass et go2rtc simultanément. Si vous utilisez Hass, je vous recommande de coupler des appareils avec celui-ci, cela vous donnera plus d'options.
Vous pouvez coupler l'appareil avec go2rtc sur la page HomeKit. Si vous ne voyez pas vos appareils, rechargez la page. Essayez également de redémarrer votre appareil HomeKit (hors tension). Si vous ne le voyez toujours pas, vous avez un problème avec mDNS.
Si vous voyez un appareil mais qu'il n'a pas de bouton de couplage, il est associé à un écosystème (Apple Home, Home Assistant, HomeBridge, etc.). Vous devez supprimer l'appareil de cet écosystème et il sera disponible pour le couplage. Si vous ne parvenez pas à dissocier l'appareil, vous devrez le réinitialiser.
Important:
L'audio HomeKit utilise un codec AAC-ELD très non standard avec des paramètres très non standard et une violation des spécifications
L'audio ne peut pas être lu dans VLC et probablement dans n'importe quel autre lecteur
L'audio doit être transcodé pour être utilisé avec MSE, WebRTC, etc.
Paramètres recommandés pour l'utilisation de la caméra HomeKit avec WebRTC, MSE, MP4, RTSP :
streams: aqara_g3: - hass:Camera-Hub-G3-AB12 - ffmpeg:aqara_g3#audio=aac#audio=opus
Lien RTSP avec audio "normal" pour n'importe quel lecteur : rtsp://192.168.1.123:8554/aqara_g3?video&audio=aac
Cette source est en développement actif ! Testé uniquement avec Aqara Camera Hub G3 (versions EU et CN).
Nouveau dans la v1.6.1
Autres noms : ESeeCloud, dvr163.
vous pouvez ignorer username , password , port , ch et stream s'ils sont par défaut
configurer des flux séparés pour différents canaux et flux
flux : caméra1 : bubble://username:[email protected]:34567/bubble/live?ch=0&stream=0
Nouveau dans la v1.2.0
Autres noms : DVR-IP, NetSurveillance, protocole Sofia (plugin NETsurveillance ActiveX XMeye SDK).
vous pouvez ignorer username , password , port , channel et subtype s'ils sont par défaut
configurer des flux séparés pour différentes chaînes
utilisez subtype=0 pour le flux principal et subtype=1 pour le flux Extra1
seul le protocole TCP est supporté
flux : only_stream : dvrip://username:[email protected]:34567?channel=0&subtype=0 only_tts : dvrip://username:[email protected]:34567?backchannel=1 two_way_audio : - dvrip://nom d'utilisateur:[email protected]:34567?channel=0&subtype=0- dvrip://nom d'utilisateur:[email protected]:34567?backchannel=1
Nouveau dans la v1.2.0
Protocole de caméra propriétaire TP-Link Tapo avec prise en charge audio bidirectionnelle .
la qualité du flux est la même que celle du protocole RTSP
utilisez le mot de passe cloud , ce n'est pas le mot de passe RTSP ! vous n'avez pas besoin d'ajouter un login !
vous pouvez également utiliser le hachage UPPERCASE MD5 à partir de votre mot de passe cloud avec le nom d'utilisateur admin
certains nouveaux firmwares de caméra nécessitent SHA256 au lieu de MD5
streams : # mot de passe cloud sans nom d'utilisateur caméra1 : tapo://[email protected] # nom d'utilisateur administrateur et hachage de mot de passe cloud MD5 en MAJUSCULES caméra2 : tapo://admin:[email protected] # nom d'utilisateur administrateur et hachage de mot de passe cloud SHA256 en MAJUSCULES caméra3 : tapo://admin:[email protected]
echo -n "mot de passe cloud" | md5 | awk '{print toupper($0)}'echo -n "mot de passe cloud" | shasum-a 256 | awk '{print topper($0)}'Nouveau dans la v1.7.0
Protocole non standard TP-Link Kasa plus d'informations.
username - e-mail urlsafe, [email protected] -> alex%40gmail.com
password - mot de passe base64, secret1 -> c2VjcmV0MQ==
flux : kc401 : kasa://username:[email protected]:19443/https/stream/mixed
Testé : KD110, KC200, KC401, KC420WS, EC71.
Nouveau dans la v1.8.3
Prend en charge le streaming depuis les caméras GoPro, connectées via USB ou Wi-Fi à Linux, Mac, Windows. En savoir plus.
Prend en charge les caméras publiques du service Ivideon.
flux : caillecam : ivideon:100-tu5dkUPct39cTp9oNEN2B6/0
Prise en charge de l'importation de liens de caméra à partir des fichiers de configuration de Home Assistant :
Caméra générique, configuration via l'interface graphique
Caméra HomeKit
ONVIF
Aspirateurs Roborock avec caméra
hass: config: "/config" # ignorez ce paramètre si vous utilisez le module complémentaire Hass userstreams : generic_camera : hass:Camera1 # Paramètres > Intégrations > Nom de l'intégration aqara_g3 : hass : Caméra-Hub-G3-AB12
Caméras WebRTC ( à partir de la v1.6.0 )
Toutes les caméras au format WebRTC sont prises en charge. Mais pour le moment, Home Assistant ne prend en charge que certaines caméras Nest dans ce format.
Important. L'API Nest vous permet uniquement d'obtenir un lien vers un flux pendant 5 minutes. Ne l'utilisez pas avec Frigate ! Si le flux expire, Frigate consommera toute la RAM disponible sur votre machine en quelques secondes. Il est recommandé d'utiliser la source Nest : elle prend en charge l'extension du flux.
flux : # lien vers Home Assistant Supervisé hass-webrtc1 : hass://supervisor?entity_id=camera.nest_doorbell # lien vers du Hass externe avec des jetons d'accès à longue durée de vie hass-webrtc2 : hass://192.168.1.123:8123?entity_id=camera.nest_doorbell&token=eyXYZ...
Caméras RTSP
Par défaut, l'API Home Assistant ne vous permet pas d'obtenir un lien RTSP dynamique vers un flux de caméra. Ainsi, davantage de caméras, comme Tuya, et éventuellement d'autres, peuvent également être importées en utilisant cette méthode.
Nouveau dans la v1.3.0
Ce type de source prend uniquement en charge l'audio de canal arrière pour le protocole Hikvision ISAPI. Il doit donc être utilisé comme seconde source en plus du protocole RTSP.
flux : hikvision1 :
- rtsp://admin:[email protected]:554/Streaming/Channels/101- isapi://admin:[email protected]:80/Nouveau dans la v1.6.0
Actuellement, seules les caméras WebRTC sont prises en charge.
Pour plus de simplicité, il est recommandé de connecter la caméra Nest/WebRTC au Home Assistant. Mais si vous parvenez à obtenir les paramètres ci-dessous, la source Nest/WebRTC fonctionnera sans Hass.
flux : nest-doorbell : nest:?client_id=***&client_secret=***&refresh_token=***&project_id=***&device_id=***
Nouveau dans la v1.3.0
Ce type de source prend en charge les aspirateurs Roborock avec caméras. Modèles de travail connus :
Roborock S6 MaxV - uniquement vidéo (l'aspirateur n'a pas de microphone)
Roborock S7 MaxV - vidéo et audio bidirectionnel
Roborock Qrevo MaxV - vidéo et audio bidirectionnel
La prise en charge de la source charge les informations d'identification Roborock à partir de l'intégration personnalisée de Home Assistant ou de l'intégration principale. Sinon, vous devez vous connecter à votre compte Roborock (le compte MiHome n'est pas pris en charge). Accédez à : go2rtc WebUI > Ajouter une page Web. Copiez la source roborock://... de votre aspirateur et collez-la dans la configuration go2rtc.yaml .
Si vous avez une broche graphique pour votre aspirateur, ajoutez-la sous forme de broche numérique (lignes : 123, 456, 789) à la fin du lien roborock.
Nouveau dans la v1.3.0
Ce type de source prend en charge quatre formats de connexion.
fouetter
WebRTC/WHEP - est remplacé par la norme WebRTC/WISH pour les visionneuses vidéo/audio WebRTC. Mais il est peut-être déjà pris en charge dans certains logiciels tiers. Il est pris en charge dans go2rtc.
aller2rtc
Ce format n'est pris en charge que dans go2rtc. Contrairement à WHEP, il prend en charge la connexion WebRTC asynchrone et l'audio bidirectionnel.
openipc ( à partir de la v1.7.0 )
Prise en charge de la connexion aux caméras OpenIPC.
wyze ( à partir de la v1.6.1 )
Prend en charge la connexion aux caméras Wyze, en utilisant le protocole WebRTC. Vous pouvez utiliser le projet docker-wyze-bridge pour obtenir les informations d'identification de connexion.
kinésie ( à partir de la v1.6.1 )
Prend en charge les flux vidéo Amazon Kinesis, en utilisant le protocole WebRTC. Vous devez spécifier l'URL de signalisation WebSocket avec toutes les informations d'identification dans la liste des paramètres de requête, client_id et ice_servers au format JSON.
flux : webrtc-whep : webrtc:http://192.168.1.123:1984/api/webrtc?src=camera1
webrtc-go2rtc : webrtc:ws://192.168.1.123:1984/api/ws?src=camera1
webrtc-openipc : webrtc:ws://192.168.1.123/webrtc_ws#format=openipc#ice_servers=[{"urls":"stun:stun.kinesisvideo.eu-north-1.amazonaws.com:443"}]
webrtc-wyze : webrtc:http://192.168.1.123:5000/signaling/camera1?kvs#format=wyze
webrtc-kinesis : webrtc:wss://...amazonaws.com/?...#format=kinesis#client_id=...#ice_servers=[{...},{...}] PS. Pour les sources kinesis vous pouvez utiliser echo pour obtenir les paramètres de connexion en utilisant bash / python ou tout autre langage de script.
Nouveau dans la v1.3.0
Cette source peut obtenir un flux d'un autre go2rtc via le protocole WebTorrent.
flux : webtorrent1 : webtorrent:?share=huofssuxaty00izc&pwd=k3l2j9djeg8v8r7e
Par défaut, go2rtc établit une connexion à la source lorsqu'un client le demande. Go2rtc abandonne la connexion à la source lorsqu'il n'a plus de client.
Go2rtc peut également accepter les sources entrantes aux formats RTSP, RTMP, HTTP et WebRTC/WHIP
Go2rtc n'arrêtera pas une telle source si elle n'a pas de clients
Vous pouvez transmettre des données uniquement vers un flux existant (créer un flux avec une source vide dans la configuration)
Vous pouvez transférer plusieurs sources entrantes vers le même flux
Vous pouvez transmettre des données vers un flux non vide afin qu'elles contiennent des codecs supplémentaires.
Exemples
RTSP avec n'importe quel codec
ffmpeg -re -i BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp rtsp://localhost:8554/camera1
HTTP-MJPEG avec le codec MJPEG
ffmpeg -re -i BigBuckBunny.mp4 -c mjpeg -f mpjpeg http://localhost:1984/api/stream.mjpeg?dst=camera1
HTTP-FLV avec codecs H264, AAC
ffmpeg -re -i BigBuckBunny.mp4 -c copy -f flv http://localhost:1984/api/stream.flv?dst=camera1
MPEG-TS avec codec H264
ffmpeg -re -i BigBuckBunny.mp4 -c copy -f mpegts http://localhost:1984/api/stream.ts?dst=camera1
Nouveau dans la v1.3.0
Vous pouvez transformer le navigateur de n'importe quel PC ou mobile en une caméra IP avec prise en charge vidéo et audio bidirectionnel. Ou même diffuser l'écran de votre PC :
Créez un flux vide dans le go2rtc.yaml
Accédez à l'interface utilisateur Web go2rtc
Ouvrir la page links pour votre flux
Sélectionnez l’option camera+microphone ou display+speaker
Ouvrez la page locale webrtc (votre go2rtc devrait fonctionner via HTTPS ! ) ou share link via la technologie WebTorrent (fonctionne via HTTPS par défaut)
Nouveau dans la v1.3.0
Vous pouvez utiliser OBS Studio ou tout autre logiciel de diffusion prenant en charge le protocole WHIP. Cette norme n'a pas encore été approuvée. Mais vous pouvez télécharger la version de développement d'OBS Studio :
Paramètres > Flux > Service : WHIP > http://192.168.1.123:1984/api/webrtc?dst=camera1
Nouveau dans la v1.3.0
go2rtc prend en charge la lecture de fichiers audio (ex. musique ou TTS) et les flux en direct (ex. radio) sur des caméras avec prise en charge audio bidirectionnelle (caméras RTSP/ONVIF, TP-Link Tapo, Hikvision ISAPI, aspirateurs Roborock, n'importe quel navigateur).
Exemple d'API :
POST http://localhost:1984/api/streams?dst=camera1&src=ffmpeg:http://example.com/song.mp3#audio=pcma#input=file
vous pouvez diffuser : des fichiers locaux, des fichiers Web, des flux en direct ou n'importe quel format, pris en charge par FFmpeg
vous devez utiliser la source ffmpeg pour transcoder l'audio en codec, que votre caméra prend en charge
vous pouvez vérifier les codecs de caméra sur la page d'informations go2rtc WebUI lorsque le flux est actif
certaines caméras ne prennent en charge que le codec PCMA/8000 de faible qualité (ex. Tapo)
il est recommandé de choisir des formats de qualité supérieure si votre appareil photo les prend en charge (ex. PCMA/48000 pour certaines caméras Dahua)
si vous lisez des fichiers via un lien http, vous devez ajouter les paramètres #input=file pour le transcodage, afin que le fichier soit transcodé et lu en temps réel
si vous diffusez des flux en direct, vous devez ignorer le paramètre #input , car il est déjà en temps réel
vous pouvez arrêter la lecture active en appelant l'API avec le paramètre src vide
vous verrez un producteur actif et un consommateur actif dans la page d'informations go2rtc WebUI pendant la diffusion en continu
Nouveau dans la v1.8.0
Vous pouvez publier n'importe quel flux sur des services de streaming (YouTube, Telegram, etc.) via RTMP/RTMPS. Important:
Codecs pris en charge : H264 pour la vidéo et AAC pour l'audio
L'audio AAC est requis pour YouTube, les vidéos sans audio ne fonctionneront pas
Vous n'avez pas besoin d'activer le module RTMP à l'écoute pour cette tâche
Vous pouvez utiliser l'API :
POST http://localhost:1984/api/streams?src=camera1&dst=rtmps://...
Ou le fichier de configuration :
publier : # publier le flux "video_audio_transcode" sur Telegram
vidéo_audio_transcode :
- rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxx
# publier le flux "audio_transcode" sur Telegram et YouTube
audio_transcode :
- rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxxxx- rtmp://xxx.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx-xxxxstreams : video_audio_transcode :
- ffmpeg:rtsp://user:[email protected]/stream1#video=h264#hardware#audio=aac
audio_transcode :
- ffmpeg:rtsp://user:[email protected]/stream1#video=copy#audio=aacApplication de bureau Telegram > N'importe quelle chaîne ou groupe public ou privé (dont vous êtes administrateur) > Diffusion en direct > Commencer par... > Démarrer la diffusion.
YouTube > Créer > Passer en direct > Latence de diffusion : latence ultra faible > Copier : URL de diffusion + Clé de diffusion.
L'API HTTP est l'élément principal permettant d'interagir avec l'application. Adresse par défaut : http://localhost:1984/ .
Important! go2rtc transmet les requêtes de localhost et du socket Unix sans autorisation HTTP, même si vous l'avez configuré ! Il est de votre responsabilité de mettre en place un accès externe sécurisé à l'API. S'il n'est pas correctement configuré, un attaquant peut accéder à vos caméras et même à votre serveur.
Description de l'API.
Configuration des modules
vous pouvez désactiver l'API HTTP avec listen: "" et utiliser, par exemple, uniquement le protocole client/serveur RTSP
vous pouvez activer l'API HTTP uniquement sur localhost avec le paramètre listen: "127.0.0.1:1984"
vous pouvez modifier l'API base_path et héberger go2rtc sur la sous-URL de votre serveur Web d'application principale
tous les fichiers de static_dir hébergés sur le chemin racine : /
vous pouvez utiliser le contenu brut du certificat/clé TLS ou le chemin d'accès aux fichiers
api : écoute : ":1984" # par défaut ":1984", port API HTTP ("" - désactivé)
nom d'utilisateur : "admin" # par défaut "", Authentification de base pour WebUI
mot de passe : "pass" # par défaut "", Authentification de base pour WebUI
base_path : "/rtc" # par défaut "", préfixe API pour la diffusion sur la suburl (/api => /rtc/api)
static_dir : "www" # default "", dossier pour les fichiers statiques (interface web personnalisée)
origin : "*" # par défaut "", autoriser les requêtes CORS (uniquement * prises en charge)
tls_listen : ":443" # par défaut "", activer le serveur HTTPS
tls_cert : | # par défaut "", certificat fullchain encodé PEM pour HTTPS -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE----- tls_key: | # par défaut "", clé privée codée PEM pour HTTPS -----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY----- unix_listen: "/tmp/go2rtc.sock " # par défaut "", écouteur de socket Unix pour l'APIPS :
MJPEG sur WebSocket fonctionne mieux que MJPEG natif à cause d'un bug de Chrome
MP4 sur WebSocket a été créé uniquement pour Apple iOS car il ne prend pas en charge MSE et MP4 natif
Vous pouvez obtenir n'importe quel flux sous forme de flux RTSP : rtsp://192.168.1.123:8554/{stream_name}
Vous pouvez activer la protection par mot de passe externe pour vos flux RTSP. La protection par mot de passe est toujours désactivée pour les appels localhost (ex. FFmpeg ou Hass sur le même serveur).
rtsp : écoute : ":8554" # Port TCP du serveur RTSP, par défaut - 8554 nom d'utilisateur : "admin" # facultatif, par défaut - désactivé mot de passe : "pass" # facultatif, par défaut - désactivé default_query : "vidéo et audio" <sp
