go2rtc
v1.9.7 - 2024-11-11
Aplicativo definitivo de streaming de câmera com suporte a RTSP, WebRTC, HomeKit, FFmpeg, RTMP, etc.
Aplicativo pequeno com dependência zero e configuração zero para todos os sistemas operacionais (Windows, macOS, Linux, ARM)
atraso zero para muitos protocolos suportados (menor latência de streaming possível)
streaming de RTSP, RTMP, DVRIP, HTTP (FLV/MJPEG/JPEG/TS), câmeras USB e outras fontes
streaming de qualquer fonte, suportado por FFmpeg
streaming para RTSP, WebRTC, MSE/MP4, HomeKit HLS ou MJPEG
publicar qualquer fonte em serviços de streaming populares (YouTube, Telegram, etc.)
primeiro projeto no mundo com suporte para streaming de câmeras HomeKit
suporte H265 para WebRTC no navegador (somente Safari, leia mais)
transcodificação instantânea para codecs não suportados via FFmpeg
reproduzir arquivos de áudio e transmissões ao vivo em algumas câmeras com alto-falante
negociação de codecs bidirecionais de múltiplas fontes
mixar faixas de diferentes fontes em um único stream
codecs suportados pelo cliente de correspondência automática
Áudio bidirecional para algumas câmeras
streaming de redes privadas via ngrok
pode ser integrado a qualquer plataforma de casa inteligente ou usado como aplicativo independente
Inspirado por:
série de projetos de streaming do @deepch
biblioteca webrtc go e toda a equipe @pion
ideia de servidor rtsp-simples de @aler9
Ideia de pipeline da estrutura GStreamer
Ideia de roteamento da estrutura MediaSoup
Protocolo de acessórios HomeKit de @brutella
criador do logotipo do projeto @v_novoseltsev
Início rápido
go2rtc: Binário
go2rtc: Docker
go2rtc: complemento do assistente doméstico
go2rtc: Integração com assistente doméstico
go2rtc: versão de desenvolvimento
Configuração
Áudio bidirecional
Fonte: RTSP
Fonte: RTMP
Fonte: HTTP
Fonte: ONVIF
Fonte: FFmpeg
Fonte: Dispositivo FFmpeg
Fonte: Executivo
Fonte: Eco
Fonte: Expr
Fonte: HomeKit
Fonte: Bolha
Fonte: DVRIP
Fonte: Tapo
Fonte: Kasa
Fonte: GoPro
Fonte: Ivideon
Fonte: Hass
Fonte: ISAPI
Fonte: Ninho
Fonte: Roborock
Fonte: WebRTC
Fonte: WebTorrent
Fontes de entrada
Transmitir para a câmera
Publicar fluxo
Módulo: Fluxos
Módulo: API
Módulo: RTSP
Módulo: RTMP
Módulo: WebRTC
Módulo: HomeKit
Módulo: WebTorrent
Módulo: ngrok
Módulo: Hass
Módulo: MP4
Módulo: HLS
Módulo: MJPEG
Módulo: Registro
Segurança
Filtros de codecs
Loucura de codecs
Negociação de codecs
Projetos usando go2rtc
Experiência de câmera
PONTAS
Perguntas frequentes
Baixe o binário ou use o complemento ou integração Docker ou Home Assistant
Interface web aberta: http://localhost:1984/
Opcionalmente:
adicione seus streams ao arquivo de configuração
configurar acesso externo ao webrtc
Desenvolvedores:
escreva sua própria interface web
integre a API da web à sua plataforma de casa inteligente
Baixe o binário para o seu sistema operacional da versão mais recente:
go2rtc_win64.zip - Windows 10+ 64 bits
go2rtc_win32.zip - Windows 7+ 32 bits
go2rtc_win_arm64.zip - Windows ARM de 64 bits
go2rtc_linux_amd64 – Linux de 64 bits
go2rtc_linux_i386 - Linux de 32 bits
go2rtc_linux_arm64 - Linux ARM de 64 bits (ex. sistema operacional Raspberry de 64 bits)
go2rtc_linux_arm - Linux ARM de 32 bits (ex. Raspberry OS de 32 bits)
go2rtc_linux_armv6 - Linux ARMv6 (para Raspberry 1 e Zero antigos)
go2rtc_linux_mipsel - Linux MIPS (ex. Xiaomi Gateway 3, câmeras Wyze)
go2rtc_mac_amd64.zip - macOS 10.13+ Intel de 64 bits
go2rtc_mac_arm64.zip - macOS ARM de 64 bits
Não se esqueça de corrigir os direitos chmod +x go2rtc_xxx_xxx no Linux e Mac.
O contêiner Docker alexxit/go2rtc oferece suporte a várias arquiteturas, incluindo amd64 , 386 , arm64 e arm . Este contêiner oferece a mesma funcionalidade do complemento Home Assistant, mas foi projetado para operar independentemente do Home Assistant. Ele vem pré-instalado com FFmpeg, ngrok e Python.
Instale o complemento:
Configurações > Complementos > Plus > Repositórios > Adicionar https://github.com/AlexxIT/hassio-addons
go2rtc > Instalar > Iniciar
Integração de configuração
O componente personalizado da câmera WebRTC pode ser usado em qualquer instalação do Home Assistant, incluindo HassWP no Windows. Ele pode baixar e usar automaticamente a versão mais recente do go2rtc. Ou pode se conectar a uma versão existente do go2rtc. A instalação do complemento neste caso é opcional.
Versão mais recente, mas talvez instável:
Binário: último lançamento noturno
Docker: versões alexxit/go2rtc:master ou alexxit/go2rtc:master-hardware
Complemento Hass: versões de hardware go2rtc master ou go2rtc master hardware
por padrão, go2rtc pesquisará go2rtc.yaml no diretório de trabalho atual
o servidor api iniciará na porta padrão 1984 (TCP)
O servidor rtsp iniciará na porta padrão 8554 (TCP)
webrtc usará a porta 8555 (TCP/UDP) para conexões
ffmpeg usará opções de transcodificação padrão
Opções de configuração e uma lista completa de configurações podem ser encontradas no wiki.
Módulos disponíveis:
fluxos
api - API HTTP (importante para suporte WebRTC)
rtsp - Servidor RTSP (importante para suporte FFmpeg)
webrtc - Servidor WebRTC
mp4 - MSE, fluxo MP4 e servidor de instantâneo MP4
hls - Servidor de fluxo HLS TS ou fMP4
mjpeg - Servidor MJPEG
ffmpeg - integração FFmpeg
ngrok - integração ngrok (acesso externo para rede privada)
hass - Integração com o Home Assistant
log - configuração de registros
go2rtc oferece suporte a diferentes tipos de fontes de fluxo. Você pode configurar um ou vários links de qualquer tipo como fonte de fluxo.
Tipos de origem disponíveis:
rtsp - câmeras RTSP e RTSPS com suporte de áudio bidirecional
rtmp - fluxos RTMP
http - HTTP-FLV , MPEG-TS , JPEG (instantâneos), fluxos MJPEG
onvif - obtém link RTSP da câmera e link de instantâneo usando o protocolo ONVIF
ffmpeg - integração FFmpeg ( HLS , files e muitos outros)
ffmpeg: dispositivo - câmera USB local ou webcam
exec – obtém mídia da saída do aplicativo externo
echo - obtém link de stream do bash ou python
expr - obtém link de stream por meio de linguagem de expressão integrada
homekit - streaming da câmera HomeKit
bolha - streaming de ESeeCloud/dvr163 NVR
dvrip - streaming de DVR-IP NVR
tapo - Câmeras TP-Link Tapo com suporte de áudio bidirecional
kasa - câmeras TP-Link Kasa
gopro - câmeras GoPro
ivideon - câmeras públicas do serviço Ivideon
hass - Integração com o Home Assistant
isapi - áudio bidirecional para câmeras Hikvision (ISAPI)
roborock - Roborock aspiradores com câmeras
webrtc - fontes WebRTC/WHEP
webtorrent - fonte WebTorrent de outro go2rtc
Leia mais sobre fontes de entrada
Compatível com fontes:
Câmeras RTSP com ONVIF Profile T (conexão de canal traseiro)
Câmeras DVRIP
Câmeras TP-Link Tapo
Câmeras ISAPI Hikvision
Roborock aspira modelos com câmeras
Áudio executivo no servidor
Qualquer navegador como câmera IP
O áudio bidirecional pode ser usado em navegador com tecnologia WebRTC. O navegador dará acesso ao microfone apenas para sites HTTPS (leia mais).
go2rtc também suporta a reprodução de arquivos de áudio e transmissões ao vivo nestas câmeras.
streams: 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://nomedeusuário:[email protected]:554/cam/realmonitor?channel=1&subtype=0#backchannel=0 câmera_unifi: rtspx://192.168.1.123:7441/fD6ouM72bWoFijxK glicy_camera: ffmpeg:rtsp://nomedeusuário:[email protected]/live/ch00_1
Recomendações
Os usuários do Amcrest Doorbell podem querer desativar o áudio bidirecional, porque com um stream ativo você não terá um botão de chamada funcionando. Você precisa adicionar #backchannel=0 ao final do seu link RTSP no arquivo de configuração YAML
Os usuários do Dahua Doorbell podem querer alterar o codec de áudio do canal traseiro
Os usuários do Reolink podem querer NÃO usar o protocolo RTSP, alguns modelos de câmera têm uma implementação de fluxo terrível e inutilizável
Os usuários do Ubiquiti UniFi podem querer desabilitar a verificação HTTPS. Use o prefixo rtspx:// em vez de rtsps:// . E não use o sufixo ?enableSrtp
Os usuários do TP-Link Tapo podem pular o login e a senha, porque go2rtc suporta login sem eles
Se sua câmera tiver dois links RTSP, você poderá adicionar ambos como fontes. Isto é útil quando os streams possuem codecs diferentes, como por exemplo áudio AAC com stream principal e áudio PCMU/PCMA com segundo stream.
Se o stream da sua câmera estiver com problemas, tente usar a fonte ffmpeg. Não adicionará carga de CPU se você não usar transcodificação
Se o stream da sua câmera estiver com muitas falhas, tente usar a transcodificação com a fonte ffmpeg
Outras opções
Formato: rtsp...#{param1}#{param2}#{param3}
Adicionar tempo limite personalizado #timeout=30 (em segundos)
Ignorar áudio - #media=video ou ignorar vídeo - #media=audio
Ignorar API de áudio bidirecional #backchannel=0 - importante para algumas câmeras com problemas
Use transporte WebSocket #transport=ws...
RTSP sobre WebSocket
streams: # WebSocket com autorização, RTSP - sem eixo-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 sobre websocket # WebSocket sem autorização, RTSP - com dahua-rtsp-ws: rtsp://user:[email protected]/cam/realmonitor?channel=1&subtype=1&proto=Private3#transport=ws://192.168.1.123/rtspoverwebsocket
Você pode obter stream do servidor RTMP, por exemplo Nginx com nginx-rtmp-module.
fluxos: rtmp_stream: rtmp://192.168.1.123/live/camera1
Tipo de conteúdo de suporte:
HTTP-FLV ( video/x-flv ) - igual ao RTMP, mas sobre HTTP
HTTP-JPEG ( image/jpeg ) - link de instantâneo da câmera, pode ser convertido por go2rtc para fluxo MJPEG
HTTP-MJPEG ( multipart/x ) - fluxo MJPEG simples sobre HTTP
MPEG-TS ( video/mpeg ) - formato de streaming legado
A fonte também suporta fluxos HTTP e TCP com detecção automática para diferentes formatos: MJPEG , H.264/H.265 bitstream , MPEG-TS .
streams: # stream [HTTP-FLV] em formato vídeo/x-flv
http_flv: http://192.168.1.123:20880/api/camera/stream/780900131155/657617
# Instantâneos [JPEG] da câmera Dahua serão convertidos em fluxo MJPEG
dahua_snap: http://admin:[email protected]/cgi-bin/snapshot.cgi?channel=1
# O fluxo [MJPEG] será proxy sem modificação
http_mjpeg: https://mjpeg.sanford.io/count.mjpeg
# [MJPEG ou fluxo de bits H.264/H.265 ou MPEG-TS]
tcp_magic: tcp://192.168.1.123:12345
# Adicione cabeçalho personalizado
custom_header: "https://mjpeg.sanford.io/count.mjpeg#header=Autorização: Portador XXX"PS. A câmera Dahua tem um bug: se você selecionar o codec MJPEG para o segundo fluxo RTSP - o instantâneo não funcionará.
Novo na v1.5.0
A fonte não é muito útil se você já conhece links RTSP e instantâneos para sua câmera. Mas pode ser útil se você não fizer isso.
WebUI > Adicionar suporte a página da web para descoberta automática ONVIF. Seu servidor deve estar na mesma sub-rede que a câmera. Se você usar o docker, deverá usar "host de rede".
fluxos: dahua1: onvif://admin:[email protected] reolink1: onvif://admin:[email protected]:8000 tapo1: onvif://admin:[email protected]:2020
Você pode obter qualquer stream, arquivo ou dispositivo via FFmpeg e enviá-lo para go2rtc. O aplicativo iniciará automaticamente o FFmpeg com os argumentos adequados quando alguém começar a assistir ao stream.
FFmpeg pré-instalado para usuários do complemento Docker e Hass
Os usuários do complemento Hass podem direcionar arquivos da pasta /media
Formato: ffmpeg:{input}#{param1}#{param2}#{param3} . Exemplos:
streams: # [FILE] todas as faixas serão copiadas sem transcodificação de codecs arquivo1: ffmpeg:/media/BigBuckBunny.mp4 # O vídeo [FILE] será transcodificado para H264, o áudio será ignorado arquivo2: ffmpeg:/media/BigBuckBunny.mp4#video=h264 # [FILE] o vídeo será copiado, o áudio será transcodificado para pcmu arquivo3: ffmpeg:/media/BigBuckBunny.mp4#video=copy#audio=pcmu # O vídeo [HLS] será copiado, o áudio será ignorado hls: ffmpeg: https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear5/prog_index.m3u8#video=copy # O vídeo [MJPEG] será transcodificado para H264 mjpeg: ffmpeg: http://185.97.122.128/cgi-bin/faststream.jpg#video=h264 # Vídeo [RTSP] com rotação, deve ser transcodificado, então selecione H264 gire: ffmpeg:rtsp://rtsp:[email protected]/av_stream/ch0#video=h264#rotate=90
Todos os formatos de transcodificação possuem modelos integrados: h264 , h265 , opus , pcmu , pcmu/16000 , pcmu/48000 , pcma , pcma/16000 , pcma/48000 , aac , aac/16000 .
Mas você pode substituí-los por meio da configuração YAML. Você também pode adicionar seus próprios formatos para configurar e usá-los com parâmetros de origem.
ffmpeg: bin: ffmpeg # caminho para o binário ffmpeg
h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
mycodec: "-qualquer argumento suportado pelo ffmpeg..."
minha entrada: "-fflags nobuffer -flags low_delay -timeout 5000000 -i {input}"
meuraw: "-ss 00:00:20" Você pode usar o nome do stream go2rtc como entrada ffmpeg (ex. ffmpeg:camera1#video=h264 )
Você pode usar parâmetros video e audio várias vezes (ex. #video=copy#audio=copy#audio=pcmu )
Você pode usar o parâmetro rotate com valores 90 , 180 , 270 ou -90 , importante com transcodificação (ex. #video=h264#rotate=90 )
Você pode usar parâmetros width e/ou height , importantes na transcodificação (ex. #video=h264#width=1280 )
Você pode usar drawtext para adicionar um carimbo de data / hora (ex. drawtext=x=2:y=2:fontsize=12:fontcolor=white:box=1:boxcolor=black )
Isso aumentará bastante a CPU do servidor, mesmo com aceleração de hardware
Você pode usar parâmetros raw para quaisquer argumentos FFmpeg adicionais (ex. #raw=-vf transpose=1 )
Você pode usar o parâmetro input para substituir o modelo de entrada padrão (ex. #input=rtsp/udp alterará o transporte RTSP de TCP para UDP+TCP)
Você pode usar o valor de entrada bruto (por exemplo, #input=-timeout 5000000 -i {input} )
Você pode adicionar seus próprios modelos de entrada
Leia mais sobre aceleração de hardware.
PS. Recomenda-se verificar o hardware disponível na página de adição do WebUI.
Você pode obter vídeo de qualquer câmera USB ou webcam como fluxo RTSP ou WebRTC. Isso faz parte da integração do FFmpeg.
verifique os dispositivos disponíveis na interface da Web
video_size e framerate devem ser suportados pela sua câmera!
para Linux suportado apenas vídeo por enquanto
para macOS, você pode transmitir a câmera Facetime ou toda a área de trabalho!
para macOS é importante definir a taxa de quadros correta
Formato: ffmpeg:device?{input-params}#{param1}#{param2}#{param3}
fluxos: 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. Recomenda-se verificar os dispositivos disponíveis na página de adição do WebUI.
A fonte Exec pode executar qualquer aplicativo externo e esperar dados dele. Dois transportes são suportados – pipe ( da versão 1.5.0 ) e RTSP .
Se você quiser usar o transporte RTSP - o comando deve conter o argumento {output} em qualquer lugar. Na inicialização, ele será substituído pelo endereço local do servidor RTSP.
pipe lê dados do aplicativo stdout em diferentes formatos: MJPEG , H.264/H.265 bitstream , MPEG-TS . Além disso, o pipe pode gravar dados no app stdin em dois formatos: PCMA e PCM/48000 .
A fonte pode ser usada com:
FFmpeg - fonte go2rtc ffmpeg apenas um atalho para a fonte exec
FFplay - reproduz áudio em seu servidor
GStreamer
Câmeras Raspberry Pi
qualquer software próprio
Os comandos de pipe suportam parâmetros (formato: exec:{command}#{param1}#{param2} ):
killsignal - sinal que será enviado para interromper o processo (formato numérico)
killtimeout - tempo em segundos para encerramento forçado com sigkill
backchannel - habilita backchannel para áudio bidirecional
streams: stream: exec:ffmpeg -re -i /media/BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp {saída}
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 -
cânone: 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=1Algumas fontes podem ter um link dinâmico. E você precisará obtê-lo usando um script bash ou python. Seu script deve ecoar um link para a fonte. RTSP, FFmpeg ou qualquer uma das fontes suportadas.
Os usuários do complemento Docker e Hass pré-instalaram python3 , curl , jq .
Verifique exemplos no wiki.
fluxos: apple_hls: echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html
Novo na v1.8.2
Como echo source, mas usa a linguagem de expressão expr integrada (leia mais).
Importante:
Você pode usar câmeras HomeKit sem dispositivos Apple (iPhone, iPad, etc.), é apenas mais um protocolo
O dispositivo HomeKit pode ser emparelhado com apenas um ecossistema. Portanto, se você o emparelhou com um iPhone (Apple Home), não poderá emparelhá-lo com o Home Assistant ou go2rtc. Ou se você o emparelhou com go2rtc - você não pode emparelhá-lo com o iPhone
O dispositivo HomeKit deve estar na mesma rede com mDNS funcionando entre o dispositivo e o go2rtc
go2rtc suporta importação de dispositivos HomeKit emparelhados do Home Assistant. Assim, você pode usar a câmera HomeKit com Hass e go2rtc simultaneamente. Se você estiver usando o Hass, recomendo emparelhar dispositivos com ele, pois isso lhe dará mais opções.
Você pode emparelhar o dispositivo com go2rtc na página do HomeKit. Se você não consegue ver seus dispositivos, recarregue a página. Tente também reiniciar o dispositivo HomeKit (desligar). Se você ainda não consegue ver, você tem problemas com o mDNS.
Se você vir um dispositivo, mas ele não tiver um botão de emparelhamento, ele está emparelhado com algum ecossistema (Apple Home, Home Assistant, HomeBridge etc.). Você precisa excluir o dispositivo desse ecossistema e ele estará disponível para emparelhamento. Se você não conseguir desemparelhar o dispositivo, será necessário redefini-lo.
Importante:
O áudio do HomeKit usa codec AAC-ELD muito fora do padrão, com parâmetros muito fora do padrão e violação de especificação
O áudio não pode ser reproduzido no VLC e provavelmente em qualquer outro player
O áudio deve ser transcodificado para uso com MSE, WebRTC, etc.
Configurações recomendadas para usar a câmera HomeKit com WebRTC, MSE, MP4, RTSP:
streams: aqara_g3: - hass:Camera-Hub-G3-AB12 - ffmpeg:aqara_g3#audio=aac#audio=opus
Link RTSP com áudio "normal" para qualquer player: rtsp://192.168.1.123:8554/aqara_g3?video&audio=aac
Esta fonte está em desenvolvimento ativo! Testado apenas com Aqara Camera Hub G3 (versões UE e CN).
Novo na v1.6.1
Outros nomes: ESeeCloud, dvr163.
você pode pular username , password , port , ch e stream se eles forem padrão
configurar streams separados para diferentes canais e streams
streams: camera1: bubble://username:[email protected]:34567/bubble/live?ch=0&stream=0
Novo na v1.2.0
Outros nomes: DVR-IP, NetSurveillance, protocolo Sofia (plugin NETsurveillance ActiveX XMeye SDK).
você pode pular username , password , port , channel e subtype se eles forem padrão
configurar streams separados para canais diferentes
use subtype=0 para stream principal e subtype=1 para stream Extra1
apenas o protocolo TCP é suportado
fluxos: only_stream: dvrip://username:[email protected]:34567?channel=0&subtype=0 only_tts: dvrip://nomedeusuário:[email protected]:34567?backchannel=1 áudio_duas vias: - dvrip://nome de usuário:[email protected]:34567?channel=0&subtype=0- dvrip://nome de usuário:[email protected]:34567?backchannel=1
Novo na v1.2.0
Protocolo de câmera proprietário TP-Link Tapo com suporte de áudio bidirecional .
a qualidade do fluxo é a mesma do protocolo RTSP
use a senha da nuvem , esta não é a senha RTSP! você não precisa adicionar um login!
você também pode usar o hash MD5 MAIÚSCULO da sua senha da nuvem com o nome de usuário admin
alguns novos firmwares de câmera requerem SHA256 em vez de MD5
streams: # senha da nuvem sem nome de usuário câmera1: tapo://[email protected] # nome de usuário do administrador e hash de senha da nuvem MD5 em MAIÚSCULAS câmera2: tapo://admin:MAIÚ[email protected] # nome de usuário do administrador e hash de senha da nuvem SHA256 em MAIÚSCULAS câmera3: tapo://admin:MAIÚ[email protected]
echo -n "senha da nuvem" | md5 | awk '{print topper($0)}'echo -n "senha da nuvem" | shasum-a 256 | awk '{imprimir topo($0)}'Novo na v1.7.0
Protocolo não padrão TP-Link Kasa mais informações.
username - email seguro para url, [email protected] -> alex%40gmail.com
password - senha base64, secret1 -> c2VjcmV0MQ==
streams: kc401: kasa://nomedeusuário:[email protected]:19443/https/stream/mixed
Testado: KD110, KC200, KC401, KC420WS, EC71.
Novo na v1.8.3
Suporta streaming de câmeras GoPro, conectadas via USB ou Wi-Fi para Linux, Mac, Windows. Leia mais.
Suporte câmeras públicas do serviço Ivideon.
streams: quailcam: ivideon:100-tu5dkUPct39cTp9oNEN2B6/0
Suporte para importação de links de câmeras dos arquivos de configuração do Home Assistant:
Câmera genérica, configuração via GUI
Câmera Home Kit
ONVIF
Roborock aspira com câmera
hass: config: "/config" # ignore esta configuração se você usar o Hass Add-on userstreams: generic_camera: hass:Camera1 # Configurações > Integrações > Nome da Integração aqara_g3: hass:Camera-Hub-G3-AB12
Câmeras WebRTC ( de v1.6.0 )
Quaisquer câmeras no formato WebRTC são suportadas. Mas no momento o Home Assistant suporta apenas algumas câmeras Nest neste formato.
Importante. A API Nest só permite que você obtenha um link para um stream por 5 minutos. Não use isso com Fragata! Se o fluxo expirar, o Frigate consumirá toda a memória RAM disponível em sua máquina em segundos. É recomendado usar a fonte Nest - ela suporta a extensão do stream.
streams: # link para Home Assistant Supervisionado hass-webrtc1: hass://supervisor?entity_id=camera.nest_doorbell # link para Hass externo com tokens de acesso de longa duração hass-webrtc2: hass://192.168.1.123:8123?entity_id=camera.nest_doorbell&token=eyXYZ...
Câmeras RTSP
Por padrão, a API Home Assistant não permite obter um link RTSP dinâmico para um stream de câmera. Assim, mais câmeras, como Tuya, e possivelmente outras, também podem ser importadas usando este método.
Novo na v1.3.0
Este tipo de fonte suporta apenas áudio de backchannel para o protocolo Hikvision ISAPI. Portanto deve ser utilizado como segunda fonte além do protocolo RTSP.
fluxos: hikvision1:
- rtsp://admin:[email protected]:554/Streaming/Channels/101- isapi://admin:[email protected]:80/Novo na v1.6.0
Atualmente apenas câmeras WebRTC são suportadas.
Para simplificar, é recomendável conectar a câmera Nest/WebRTC ao Home Assistant. Mas se você conseguir de alguma forma obter os parâmetros abaixo - a fonte Nest/WebRTC funcionará sem Hass.
streams: ninho-doorbell: ninho:?client_id=***&client_secret=***&refresh_token=***&project_id=***&device_id=***
Novo na v1.3.0
Este tipo de fonte oferece suporte a aspiradores Roborock com câmeras. Modelos de trabalho conhecidos:
Roborock S6 MaxV – apenas vídeo (o aspirador não tem microfone)
Roborock S7 MaxV - vídeo e áudio bidirecional
Roborock Qrevo MaxV - vídeo e áudio bidirecional
O suporte de origem carrega credenciais do Roborock da integração personalizada do Home Assistant ou da integração principal. Caso contrário, você precisará fazer login na sua conta Roborock (a conta MiHome não é suportada). Vá para: go2rtc WebUI > Adicionar página da web. Copie roborock://... fonte para o seu vácuo e cole-o na configuração go2rtc.yaml .
Se você tiver um pino gráfico para o seu aspirador - adicione-o como um pino numérico (linhas: 123, 456, 789) ao final do link roborock.
Novo na v1.3.0
Este tipo de fonte suporta quatro formatos de conexão.
caralho
WebRTC/WHEP - foi substituído pelo padrão WebRTC/WISH para visualizadores de vídeo/áudio WebRTC. Mas já pode ser compatível com algum software de terceiros. É compatível com go2rtc.
go2rtc
Este formato é compatível apenas com go2rtc. Ao contrário do WHEP, ele suporta conexão WebRTC assíncrona e áudio bidirecional.
openipc ( de v1.7.0 )
Suporte para conexão com câmeras OpenIPC.
wyze ( da v1.6.1 )
Suporta conexão com câmeras Wyze, usando protocolo WebRTC. Você pode usar o projeto docker-wyze-bridge para obter credenciais de conexão.
cinesia ( de v1.6.1 )
Suporta Amazon Kinesis Video Streams, usando protocolo WebRTC. Você precisa especificar o URL de sinalização do WebSocket com todas as credenciais nos parâmetros de consulta, lista client_id e ice_servers no formato JSON.
fluxos: 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. Para fontes kinesis você pode usar echo para obter parâmetros de conexão usando bash / python ou qualquer outra linguagem de script.
Novo na v1.3.0
Esta fonte pode obter um stream de outro go2rtc via protocolo WebTorrent.
fluxos: webtorrent1: webtorrent:?share=huofssuxaty00izc&pwd=k3l2j9djeg8v8r7e
Por padrão, go2rtc estabelece uma conexão com a fonte quando qualquer cliente a solicita. Go2rtc interrompe a conexão com a origem quando não há mais clientes.
Go2rtc também pode aceitar fontes de entrada nos formatos RTSP, RTMP, HTTP e WebRTC/WHIP
Go2rtc não irá parar tal fonte se não tiver clientes
Você pode enviar dados apenas para o stream existente (criar stream com fonte vazia na configuração)
Você pode enviar várias fontes de entrada para o mesmo fluxo
Você pode enviar dados para um fluxo não vazio, portanto, haverá codecs adicionais dentro
Exemplos
RTSP com qualquer codec
ffmpeg -re -i BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp rtsp://localhost:8554/camera1
HTTP-MJPEG com codec MJPEG
ffmpeg -re -i BigBuckBunny.mp4 -c mjpeg -f mpjpeg http://localhost:1984/api/stream.mjpeg?dst=camera1
HTTP-FLV com codecs H264 e AAC
ffmpeg -re -i BigBuckBunny.mp4 -c copy -f flv http://localhost:1984/api/stream.flv?dst=camera1
MPEG-TS com codec H264
ffmpeg -re -i BigBuckBunny.mp4 -c copy -f mpegts http://localhost:1984/api/stream.ts?dst=camera1
Novo na v1.3.0
Você pode transformar o navegador de qualquer PC ou celular em uma câmera IP com suporte para vídeo e áudio bidirecional. Ou até mesmo transmita a tela do seu PC:
Crie um fluxo vazio em go2rtc.yaml
Vá para go2rtc WebUI
Abra a página links para seu stream
Selecione a opção camera+microphone ou display+speaker
Abra a página local webrtc (seu go2rtc deve funcionar em HTTPS! ) ou share link via tecnologia WebTorrent (funciona em HTTPS por padrão)
Novo na v1.3.0
Você pode usar o OBS Studio ou qualquer outro software de transmissão com suporte ao protocolo WHIP. Esta norma ainda não foi aprovada. Mas você pode baixar a versão de desenvolvimento do OBS Studio:
Configurações > Stream > Serviço: WHIP > http://192.168.1.123:1984/api/webrtc?dst=camera1
Novo na v1.3.0
O suporte go2rtc reproduz arquivos de áudio (por exemplo, música ou TTS) e transmissões ao vivo (por exemplo, rádio) em câmeras com suporte de áudio bidirecional (câmeras RTSP/ONVIF, TP-Link Tapo, Hikvision ISAPI, aspiradores Roborock, qualquer navegador).
Exemplo de API:
POST http://localhost:1984/api/streams?dst=camera1&src=ffmpeg:http://example.com/song.mp3#audio=pcma#input=file
você pode transmitir: arquivos locais, arquivos da web, transmissões ao vivo ou qualquer formato, suportado pelo FFmpeg
você deve usar a fonte ffmpeg para transcodificar áudio para codec, que sua câmera suporta
você pode verificar os codecs da câmera na página de informações do go2rtc WebUI quando o stream está ativo
algumas câmeras suportam apenas codec PCMA/8000 de baixa qualidade (ex. Tapo)
é recomendado escolher formatos de qualidade superior se sua câmera os suportar (ex. PCMA/48000 para algumas câmeras Dahua)
se você reproduzir arquivos através do link http, precisará adicionar parâmetros #input=file para transcodificação, para que o arquivo seja transcodificado e reproduzido em tempo real
se você reproduz transmissões ao vivo, você deve pular o parâmetro #input , porque já está em tempo real
você pode interromper a reprodução ativa chamando a API com o parâmetro src vazio
você verá um produtor ativo e um consumidor ativo na página de informações do go2rtc WebUI durante a transmissão
Novo na v1.8.0
Você pode publicar qualquer stream em serviços de streaming (YouTube, Telegram, etc.) via RTMP/RTMPS. Importante:
Codecs suportados: H264 para vídeo e AAC para áudio
O áudio AAC é necessário para o YouTube, vídeos sem áudio não funcionarão
Você não precisa ativar a escuta do módulo RTMP para esta tarefa
Você pode usar API:
POST http://localhost:1984/api/streams?src=camera1&dst=rtmps://...
Ou arquivo de configuração:
publicar: # publica stream "video_audio_transcode" no Telegram
video_audio_transcode:
- rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxx
# publica o stream "audio_transcode" no Telegram e no 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://usuário:[email protected]/stream1#video=h264#hardware#audio=aac
audio_transcode:
- ffmpeg:rtsp://usuário:[email protected]/stream1#video=copy#audio=aacAplicativo Telegram Desktop > Qualquer canal ou grupo público ou privado (onde você administra) > Transmissão ao vivo > Começar com... > Iniciar transmissão.
YouTube > Criar > Transmitir ao vivo > Latência de transmissão: latência ultrabaixa > Copiar: URL de transmissão + Chave de transmissão.
A API HTTP é a parte principal de interação com o aplicativo. Endereço padrão: http://localhost:1984/ .
Importante! go2rtc passa solicitações de localhost e de soquete unix sem autorização HTTP, mesmo que você o tenha configurado! É sua responsabilidade configurar o acesso externo seguro à API. Se não for configurado corretamente, um invasor pode obter acesso às suas câmeras e até mesmo ao seu servidor.
Descrição da API.
Configuração do módulo
você pode desabilitar a API HTTP com listen: "" e usar, por exemplo, apenas o protocolo cliente/servidor RTSP
você pode ativar a API HTTP apenas no localhost com a configuração listen: "127.0.0.1:1984"
você pode alterar a API base_path e hospedar go2rtc no suburl do servidor web do seu aplicativo principal
todos os arquivos de static_dir hospedados no caminho raiz: /
você pode usar conteúdo bruto de certificado/chave TLS ou caminho para arquivos
api: listen: ":1984" # default ":1984", porta HTTP API ("" - desabilitada)
nome de usuário: "admin" # default "", Autenticação básica para WebUI
senha: "pass" # default "", Autenticação básica para WebUI
base_path: "/rtc" # default "", prefixo da API para servir no suburl (/api => /rtc/api)
static_dir: "www" # default "", pasta para arquivos estáticos (interface web personalizada)
origin: "*" # default "", permite solicitações CORS (apenas * suportado)
tls_listen: ":443" # default "", habilita servidor HTTPS
tls_cert: | # default "", certificado fullchain codificado em PEM para HTTPS -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE----- tls_key: | # default "", chave privada codificada em PEM para HTTPS -----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY----- unix_listen: "/tmp/go2rtc.sock " # default "", ouvinte de soquete unix para APIPS:
MJPEG sobre WebSocket funciona melhor que MJPEG nativo devido a bug do Chrome
MP4 sobre WebSocket foi criado apenas para Apple iOS porque não suporta MSE e MP4 nativo
Você pode obter qualquer stream como stream RTSP: rtsp://192.168.1.123:8554/{stream_name}
Você pode ativar a proteção externa por senha para seus fluxos RTSP. A proteção por senha sempre está desabilitada para chamadas de host local (ex. FFmpeg ou Hass no mesmo servidor).
rtsp: listen: ":8554" # Porta TCP do servidor RTSP, padrão - 8554 nome de usuário: "admin" # opcional, padrão - desabilitado senha: "pass" # opcional, padrão - desabilitado default_query: "vídeo e áudio" <sp
