┌─────────────────────────────────────────────────────────────────┐
│                          ESTÚDIO (TX)                            │
│                                                                  │
│  Console / Automação → VB-Cable / VoiceMeeter                    │
│                              │                                   │
│                              ▼                                   │
│                     ┌──────────────────┐                         │
│                     │   Liquidsoap TX  │  normalize → compress   │
│                     │   (WSL2/Docker)  │  → limit → Opus 128k    │
│                     └────────┬─────────┘                         │
│                              │ SRT listener :9000 (AES-256)      │
└──────────────────────────────┼───────────────────────────────────┘
                               │
                  ┌────────────┼────────────┐    Internet pública
                  │            │            │    (UDP, NAT/Firewall)
                  ▼            ▼            ▼
        ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
        │  RX-A       │ │  RX-B       │ │  RX-N       │
        │ Liquidsoap  │ │ Liquidsoap  │ │ Liquidsoap  │
        │ SRT caller  │ │ SRT caller  │ │ SRT caller  │
        │     │       │ │     │       │ │     │       │
        │     ▼       │ │     ▼       │ │     ▼       │
        │ Placa áudio │ │ Icecast LAN │ │ AES/EBU out │
        └─────────────┘ └─────────────┘ └─────────────┘

Banda_uplink = bitrate_opus × overhead_srt × N_RXs

Onde:
  overhead_srt ≈ 1.15  (cabeçalhos SRT + UDP + IP)
  oheadbw      = 25%   (margem para retransmissão ARQ — padrão SRT)

Exemplo: 128 kbps × 1.15 × 10 RXs = 1.472 Mbps mínimo
Com oheadbw 25%:                    ≈ 1.84 Mbps recomendado
Provisione +30% de folga:           ≈ 2.4 Mbps

# Abrir PowerShell como Admin (Win+X → Terminal (Admin))
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine -Force
Get-ExecutionPolicy -List

# Ativar plano "Alto desempenho"
powercfg -setactive SCHEME_MIN

# Nunca desligar display nem suspender (AC + DC)
powercfg -change -monitor-timeout-ac 0
powercfg -change -monitor-timeout-dc 0
powercfg -change -standby-timeout-ac 0
powercfg -change -standby-timeout-dc 0
powercfg -change -hibernate-timeout-ac 0
powercfg -h off  # desabilita hibernação totalmente

New-NetFirewallRule -DisplayName "SRT-Liquidsoap-Listener" \
  -Direction Inbound -Protocol UDP -LocalPort 9000 \
  -Action Allow -Profile Any

w32tm /config /syncfromflags:manual /manualpeerlist:"a.st1.ntp.br,b.st1.ntp.br,pool.ntp.org" /reliable:yes /update
Restart-Service w32time
w32tm /resync /force
w32tm /query /status

# Instalar WSL2 com Ubuntu 24.04
wsl --install -d Ubuntu-24.04
wsl --set-default-version 2
wsl --update

# Reiniciar e abrir o Ubuntu para criar usuário

sudo apt update && sudo apt upgrade -y
sudo apt install -y software-properties-common
sudo add-apt-repository -y ppa:savonet/liquidsoap-master
sudo apt update
sudo apt install -y liquidsoap liquidsoap-plugin-all ffmpeg

liquidsoap --version
# Deve retornar 2.2.x ou superior, com suporte a srt e opus

[wsl2]
networkingMode=mirrored
firewall=true
dnsTunneling=true
autoProxy=true

[experimental]
hostAddressLoopback=true

wsl --shutdown
# Reabrir o Ubuntu. Agora a porta UDP 9000 do WSL = porta 9000 do host.

# Baixar e instalar MSYS2: https://www.msys2.org/
# Abrir "MSYS2 MINGW64" e executar:
pacman -Syu
pacman -S mingw-w64-x86_64-{toolchain,opam,pkg-config,opus,ffmpeg}
opam init --disable-sandboxing
opam switch create 5.1.1
eval $(opam env)
opam install -y liquidsoap srt opus ffmpeg

# Instalar Docker Desktop, habilitar WSL2 backend
docker pull savonet/liquidsoap:rolling-release-2.2.x

# Rodar TX expondo UDP/9000
docker run -d --name liquidsoap-tx --restart=unless-stopped \
  -p 9000:9000/udp \
  -v C:\liquidsoap:/etc/liquidsoap \
  savonet/liquidsoap:rolling-release-2.2.x \
  /etc/liquidsoap/tx.liq

liquidsoap --version
liquidsoap --list-plugins | grep -E '(srt|opus|ffmpeg)'
liquidsoap --check 'output.dummy(mksafe(noise()))'

ffmpeg -list_devices true -f dshow -i dummy 2>&1 | findstr "CABLE\|VoiceMeeter"

@echo off
ffmpeg -hide_banner -loglevel warning ^
  -f dshow -audio_buffer_size 50 ^
  -i audio="CABLE Output (VB-Audio Virtual Cable)" ^
  -ac 2 -ar 48000 -f s16le -acodec pcm_s16le -

# Via input.ffmpeg direto (mais simples, requer ffmpeg na mesma máquina)
src = input.ffmpeg(
  format = "dshow",
  "audio=CABLE Output (VB-Audio Virtual Cable)"
)

# Alternativa: via pipe TCP (se o WSL não enxerga DirectShow)
src = input.harbor("live", port=8000, password="mudeisso")

#!/usr/bin/liquidsoap

# ========== Configurações globais ==========
settings.frame.audio.samplerate := 48000
settings.frame.audio.channels   := 2
settings.log.file               := true
settings.log.file.path          := "/var/log/liquidsoap/tx.log"
settings.log.stdout             := true
settings.log.level              := 3
settings.server.telnet          := true
settings.server.telnet.bind_addr:= "127.0.0.1"
settings.server.telnet.port     := 1234

# ========== Fonte principal (ingest) ==========
live = input.ffmpeg(
  format = "dshow",
  "audio=CABLE Output (VB-Audio Virtual Cable)"
)

# Detecção de silêncio: se >5s sem áudio, marca como inválido
live = blank.strip(max_blank=5., threshold=-50., live)

# ========== Fallback de emergência ==========
emergency = playlist(
  reload_mode = "watch",
  mode = "randomize",
  "/etc/liquidsoap/emergency"
)
emergency = mksafe(emergency)

# Fallback: live → emergency → silence
source = fallback(
  track_sensitive = false,
  [live, emergency, blank()]
)

# ========== Processamento DSP ==========
source = normalize(source, target=-14., window=0.5, gain_min=-12., gain_max=12.)
source = compress(source, ratio=3., threshold=-18., attack=10., release=200.)
source = limit(source, threshold=-1., attack=5., release=50.)

# ========== Saída SRT (listener, AES-256) ==========
output.srt(
  mode      = "listener",
  port      = 9000,
  bind_address = "0.0.0.0",
  passphrase   = "TROQUE_ESTA_SENHA_FORTE_32CHARS",
  pbkeylen     = 32,        # 32 bytes = AES-256
  latency      = 400,       # ms — ajustar conforme RTT
  streamid     = "tx/main",
  payload_size = 1316,      # MTU-safe para SRT/UDP
  messageapi   = false,     # live mode
  %ffmpeg(
    format  = "mpegts",
    %audio(
      codec   = "libopus",
      b       = "128k",
      ac      = 2,
      ar      = 48000,
      vbr     = "constrained",
      compression_level = 10,
      frame_duration    = 20,
      application       = "audio"
    )
  ),
  source
)

# Baixar NSSM: https://nssm.cc/download
# Extrair para C:\nssm\

C:\nssm\nssm.exe install LiquidsoapTX
# Application: C:\Windows\System32\wsl.exe
# Arguments:   -d Ubuntu-24.04 -- liquidsoap /etc/liquidsoap/tx.liq
# Startup directory: C:\
# I/O tab → redirect stdout/stderr para C:\logs\tx-stdout.log e tx-stderr.log
# Details tab → Startup type: Automatic
# Process tab → Priority: High

C:\nssm\nssm.exe start LiquidsoapTX

#!/usr/bin/liquidsoap

settings.frame.audio.samplerate := 48000
settings.frame.audio.channels   := 2
settings.log.file               := true
settings.log.file.path          := "/var/log/liquidsoap/rx.log"
settings.server.telnet          := true
settings.server.telnet.port     := 1234

# ========== Input SRT (caller para o TX) ==========
srt_input = input.srt(
  mode      = "caller",
  host      = "tx.minharadio.com.br",   # IP ou hostname do TX
  port      = 9000,
  passphrase   = "TROQUE_ESTA_SENHA_FORTE_32CHARS",
  pbkeylen     = 32,
  latency      = 400,
  streamid     = "rx/site-a",
  payload_size = 1316,
  max          = 10.,                   # buffer interno em segundos
  on_connect   = fun () -> log("SRT conectado ao TX"),
  on_disconnect= fun () -> log("SRT desconectado — tentando reconectar"),
  content_type = "application/ffmpeg;format=mpegts"
)

# ========== Fallback local (música de emergência) ==========
backup = playlist(
  reload_mode = "watch",
  mode = "randomize",
  "/etc/liquidsoap/backup"
)
backup = mksafe(backup)

source = fallback(
  track_sensitive = false,
  [srt_input, backup, blank()]
)

# ========== Saídas ==========

# (1) Placa de som física (driver ALSA dentro do WSL via PulseAudio, ou ao no nativo)
output.ao(id="placa_principal", fallible=true, source)

# (2) Redistribuição via Icecast local para a LAN da emissora
output.icecast(
  %opus(bitrate=128, channels=2, signal="music", application="audio"),
  host = "127.0.0.1",
  port = 8000,
  password = "hackme",
  mount = "/live.opus",
  name  = "STL Local Relay",
  source
)

# 32 bytes random em base64
[Convert]::ToBase64String((1..24 | ForEach-Object {Get-Random -Maximum 256}))

%include "/etc/liquidsoap/secrets.liq"

output.srt(
  mode = "listener",
  port = 9000,
  passphrase = srt_passphrase,   # definido em secrets.liq
  pbkeylen   = 32,
  ...
)

# Definir prioridade Alta no NSSM (Properties → Process tab → Priority: High)
# Ou via PowerShell em tempo de execução:
$p = Get-Process liquidsoap -ErrorAction SilentlyContinue
if ($p) {
  $p.PriorityClass = 'High'
  $p.ProcessorAffinity = 0x0C   # CPUs 2 e 3 dedicadas (máscara binária)
}

# Game Mode
Set-ItemProperty -Path "HKCU:\Software\Microsoft\GameBar" -Name "AllowAutoGameMode" -Value 0
Set-ItemProperty -Path "HKCU:\Software\Microsoft\GameBar" -Name "AutoGameModeEnabled" -Value 0

# Notificações
Set-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\PushNotifications" -Name "ToastEnabled" -Value 0

# SysMain (Superfetch) — pode causar picos de I/O
Stop-Service SysMain -Force; Set-Service SysMain -StartupType Disabled

# Telemetria
Stop-Service DiagTrack -Force; Set-Service DiagTrack -StartupType Disabled

Add-MpPreference -ExclusionPath "C:\Program Files\WSL"
Add-MpPreference -ExclusionPath "\\wsl$\Ubuntu-24.04\usr\bin\liquidsoap"
Add-MpPreference -ExclusionPath "C:\liquidsoap"
Add-MpPreference -ExclusionProcess "liquidsoap.exe"
Add-MpPreference -ExclusionProcess "wsl.exe"

# Avisa o Liquidsoap para encerrar limpo
$tcp = New-Object System.Net.Sockets.TcpClient('127.0.0.1', 1234)
$stream = $tcp.GetStream()
$writer = New-Object System.IO.StreamWriter($stream)
$writer.WriteLine('shutdown')
$writer.Flush()
Start-Sleep -Seconds 3
$tcp.Close()

Stop-Service LiquidsoapTX
Start-Sleep -Seconds 5
Stop-Computer -Force

# Conectar via telnet local
echo "uptime" | nc 127.0.0.1 1234
echo "list"   | nc 127.0.0.1 1234
echo "var.list" | nc 127.0.0.1 1234

# Comandos úteis:
#   uptime              — tempo desde o start
#   request.alive       — fontes ativas
#   <source>.skip       — pula faixa
#   <source>.remaining  — tempo restante
#   shutdown            — encerra limpo

harbor.http.register(port=8001, method="GET", "/status", fun (_, _) -> begin
  status = json.stringify(payload = [
    ("uptime",     string_of_seconds(time() - startup_time)),
    ("source",     source.id(live)),
    ("is_ready",   "#{source.is_ready(live)}"),
    ("clients",    "#{srt.stats(srt_out).accepted_sockets}")
  ])
  http.response(
    code = 200,
    headers = [("Content-Type", "application/json")],
    data = status
  )
end)

# Pinga o TX-A a cada 10s; após 3 falhas consecutivas, promove TX-B
$primary = "tx-a.minharadio.com.br"
$failures = 0
$threshold = 3

while ($true) {
  if (Test-Connection -ComputerName $primary -Count 1 -Quiet -TimeoutSeconds 2) {
    $failures = 0
  } else {
    $failures++
    if ($failures -ge $threshold) {
      Write-Host "[$(Get-Date)] Promovendo TX-B"
      # Atualizar DNS via API (Cloudflare, Route53, etc.)
      Invoke-RestMethod -Uri $env:DNS_API -Method PATCH \
        -Headers @{Authorization="Bearer $env:DNS_TOKEN"} \
        -Body (@{content=$env:TX_B_IP} | ConvertTo-Json)
      $failures = 0
      Start-Sleep -Seconds 120  # cooldown
    }
  }
  Start-Sleep -Seconds 10
}

# Listar conexões UDP na porta SRT
netstat -an | findstr ":9000"

# Testar SRT isoladamente (sem Liquidsoap)
# No TX:
srt-live-transmit -t:5 srt://:9000 file://con

# No RX:
srt-live-transmit srt://tx.minharadio.com.br:9000 file://con

# Inspecionar stream
ffprobe -hide_banner -i "srt://tx.minharadio.com.br:9000?streamid=rx/debug&passphrase=..."

# Capturar tráfego para análise (Wireshark)
pktmon start --capture --pkt-size 0 -p UDP --port 9000

srt_passphrase = "GERAR_32_CHARS_RANDOM_AQUI"
icecast_password = "outra_senha_forte"
telnet_host = "127.0.0.1"