Forem: spechshop

SpechPhone: Softphone SIP Web com PHP (Swoole) e WebSockets 🚀

spechshop — Tue, 06 Jan 2026 10:01:01 +0000

Olá, comunidade! 👋

Estou animado para compartilhar o status atual do SpechPhone, um softphone SIP web open-source que desafia o convencional ao não utilizar WebRTC. Em vez disso, utilizamos o poder do PHP com Swoole no backend para processamento de mídia em tempo real e WebSockets para o transporte de áudio PCM.

O projeto está evoluindo rapidamente e gostaria de mostrar como está a interface e as funcionalidades disponíveis hoje.

📱 Interface Principal (Dialer)

A interface de chamada foi projetada para ser intuitiva e responsiva. Temos um discador completo com feedback visual, controles de volume independentes para microfone e retorno de áudio, além de indicadores de nível de sinal (VU meters).

Tela principal: Discador, controles de chamada e monitoramento de áudio.

Bastidores Técnicos:
O front-end interage com handlers específicos para gerenciar o estado da chamada:

startCall.php: Ao discar, este handler cria uma corrotina Swoole dedicada que gerencia toda a sinalização SIP (INVITE) e aloca portas UDP dinâmicas para o RTP.

checkCall.php: Atua como um heartbeat, sincronizando o status da UI (timer, botões) com a corrotina no backend.

dtmf.php: O envio de tons utiliza o padrão RFC 2833, injetando eventos diretamente no stream RTP via PHP.

hangUpCall.php: Garante o encerramento limpo (BYE) e a liberação imediata dos recursos de áudio.

📄 plugins/Message/handlers/startCall.php:44
public static function resolve(Server $socket, array $model, int $fd): ?bool
{
   $data = $model['data'];
   $vault = new \spechphoneVault('/data/spechphone/devices.vault', getenv('SPECH_VAULT_KEY_HEX'));
   // ...

🎧 Suporte Avançado a Codecs

Uma das grandes vantagens da nossa arquitetura é o controle total sobre a transcodificação. O SpechPhone suporta nativamente uma grande variedade de codecs, processados diretamente no backend PHP.

Na aba de Áudio, é possível visualizar e selecionar os codecs disponíveis:

G.729 & Opus: Para alta compressão e qualidade.
PCMA/PCMU: Padrões clássicos G.711.
Wideband: G.722, Speex, L16 (até 48kHz).
GSM & iLBC: Para cenários de banda estreita.

Painel de Codecs: No final todos se tornarão PCM devolvido para o browser.

Bastidores Técnicos:
A mágica acontece na integração entre o startCall.php e o servidor de áudio audio.php:

Pipeline de Áudio (Sem WebRTC): O navegador envia/recebe PCM raw via WebSocket (porta 8888) para o audio.php.

Bridge UDP: O audio.php encaminha esse áudio via UDP local (porta 9600) para a corrotina da chamada.

Transcoding Nativo: O PHP recebe o PCM, aplica a codificação selecionada (ex: comprime para G.729 ou Opus) usando a biblioteca libspech e envia para o tronco SIP. O processo inverso (decodificação) ocorre na chegada dos pacotes RTP, garantindo compatibilidade universal sem depender de codecs do browser.

📄 audio.php:54
$udp = new Swoole\Coroutine\Socket(AF_INET, SOCK_DGRAM, 0);
$udp->bind("0.0.0.0", 9600);
echo "🎧 Servidor UDP aguardando pacotes em 9600...\n";

⚙️ Configuração SIP Simplificada

Conectar-se ao seu servidor VoIP (Asterisk, FreeSWITCH, Opensips) é simples. A tela de configurações permite definir o servidor, credenciais de autenticação e o codec preferencial para o tronco SIP.

Configuração da conta SIP e preferências de conexão.

Bastidores Técnicos:
A segurança e a validação são prioridades no handler saveConfig.php:

Validação Ativa: Antes de salvar, o sistema instancia um trunkController e tenta realizar um registro real (SIP REGISTER) no servidor.

Feedback Imediato: Se as credenciais estiverem erradas, o usuário é notificado na hora, evitando configurações "quebradas".

Persistência Segura: Apenas após o sucesso (200 OK), os dados são criptografados e armazenados no devices.vault. O handler register.php pode então ser usado para manter a sessão ativa (keep-alive).

📄 plugins/Message/handlers/saveConfig.php:103
if (!$trunkController->register(5)) {
   return $socket->push($fd, json_encode([
       'type' => 'notify',
       'data' => [
           'type' => 'bg-danger text-white',
           'message' => "Registro falhou, verifique as credenciais fornecidas"
       ]
   ]));
}

O projeto está em fase Beta e o desenvolvimento continua ativo, focado agora em aprimorar a estabilidade e implementar o recebimento de chamadas.

🔗 Confira o código e contribua no GitHub: https://github.com/spechshop/spechphone

Fiquem ligados para mais novidades! 🚀

VOIP Calls + Resample + PHP

spechshop — Sun, 04 Jan 2026 04:17:39 +0000

VoIP Real-Time e Áudio 48 kHz no PHP: Guia Hands-On com Swoole

Este guia demonstra como construir um softphone completo com áudio de alta qualidade (48 kHz) usando PHP moderno com Swoole. Vamos explorar VoIP e processamento de áudio em tempo real através de uma implementação prática.

Nota importante sobre arquitetura: O SpechPhone que vamos explorar funciona de um jeito diferente do que você talvez esteja acostumado. Aqui, subimos dois servidores PHP (middleware.php e audio.php) que entregam áudio via RTP no backend + WebSocket (PCM) pro browser — sem passar pelo caminho tradicional do Asterisk/AGI. É uma abordagem mais direta que facilita a compreensão do fluxo completo.
Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

O que você vai construir (de verdade)

Ao final deste guia, você terá nas mãos:

Um softphone web funcional que faz SIP/RTP em tempo real, com interface no browser via WebSocket
Um pipeline de mídia completo onde o backend recebe RTP, decodifica e envia PCM em chunks pro cliente
Uma implementação prática de I/O assíncrono com corrotinas por sessão

E o melhor: você vai entender cada peça desse quebra-cabeça.

1) Entendendo a arquitetura

Vamos começar pelo básico: como tudo isso se encaixa? O SpechPhone é construído sobre PHP + Swoole, trabalhando com mídia em RTP/UDP no backend e PCM via WebSocket direto pro browser. Nada de WebRTC/SRTP/ICE/DTLS aqui — é uma abordagem mais crua e direta, o que facilita muito pra entender o que está acontecendo em cada camada.

Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Os dois pilares da aplicação:

middleware.php: servidor HTTP/WebSocket para interface web e controle de chamadas + servidor UDP para sinalização SIP
audio.php: servidor HTTP/WebSocket + UDP que recebe streams RTP decodificados, mixa múltiplos canais de áudio e distribui via WebSocket para os clientes

Cada um tem seu papel bem definido, e você vai ver como eles conversam entre si.

Referência: https://github.com/spechshop/spechphone (seção "Directory Structure" do README)

2) O segredo do Swoole: corrotinas e I/O assíncrono

O conceito fundamental aqui é I/O assíncrono com corrotinas. Independente da linguagem, quando você domina esse padrão, consegue lidar com operações em tempo real de forma eficiente.

O SpechPhone abre uma coroutine dedicada pra cada trunkController, o que significa que você pode ter várias chamadas simultâneas rodando sem bloquear o processo principal. É a aplicação prática de concorrência cooperativa — um padrão que funciona em qualquer ecossistema que o implemente.

Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Detalhe importante: Estamos falando de Swoole (a extensão/runtime oficial), não OpenSwoole. São projetos diferentes, então fique atento na hora de instalar.

3) Mão na massa: subir o SpechPhone localmente

Hora de colocar a mão no teclado. O README do SpechPhone já entrega tudo mastigado: clone, instale o runtime e suba os servidores. Simples assim.

# deps
sudo apt update && sudo apt install -y openssl

# repo + lib
git clone https://github.com/spechshop/spechphone && cd spechphone
git clone https://github.com/spechshop/libspech

# runtime php otimizado (pcg729)
curl -L https://github.com/spechshop/pcg729/releases/download/current/php -o php
chmod +x ./php
sudo cp php /usr/local/bin/php

# start (em terminais separados)
php middleware.php
php audio.php

Referência do trecho acima: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Dica prática: Abra dois terminais lado a lado. Deixe os logs rolando e observe como os servidores se comunicam. É bem instrutivo ver o fluxo acontecendo em tempo real.

4) Áudio 48 kHz: onde entra (de verdade) e por que isso importa

Aqui é onde a coisa fica interessante. Quando falamos de telefonia tradicional, você está preso a 8 kHz (aquele som meio "de telefone", sabe?). Mas com Opus a 48 kHz, você tem qualidade de áudio próxima do que ouve em streaming de música. É uma diferença que você sente na primeira chamada.

O SpechPhone trabalha com duas peças que se complementam:

1) Oferta de Opus/48kHz via SDP no trunkController (libspech). É aqui que você diz pro outro lado: "ei, eu falo Opus em alta qualidade":

// Oferecer codec Opus em SDP
$phone->mountLineCodecSDP('opus/48000/2');

Referência do snippet: https://github.com/spechshop/libspech/blob/spech/README.md

2) Decodificação dinâmica + PCM em chunks pro browser. Os pacotes RTP chegam, são processados pela libspech (usando funções nativas via runtime pcg729), e o áudio decodificado é entregue ao controlador WebSocket em PCM puro, pronto pra ser consumido no browser via webkitAudioContext.

Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Em outras palavras: você negocia Opus, recebe RTP, decodifica e entrega PCM. Simples, direto e poderoso.

5) Um exemplo mínimo de chamada — vendo corrotinas e eventos na prática

Esse é o "hello world" da stack. Aqui você registra no servidor SIP, oferece o codec, reage a eventos (tocando, atendido, desligado) e recebe áudio. Tudo isso em menos de 50 linhas:

<?php
use libspech\Sip\trunkController;

include 'plugins/autoloader.php';

\Swoole\Coroutine\run(function () {
    $username = getenv('SIP_USERNAME');
    $password = getenv('SIP_PASSWORD');
    $domain   = getenv('SIP_DOMAIN');
    $host     = gethostbyname($domain);

    $phone = new trunkController($username, $password, $host, 5060);

    if (!$phone->register(2)) {
        throw new \Exception('Falha no registro');
    }

    // Oferecer codec Opus em SDP (48 kHz)
    $phone->mountLineCodecSDP('opus/48000/2');

    $phone->onRinging(function ($phone) {
        echo "Tocando...\n";
    });

    $phone->onAnswer(function (trunkController $phone) {
        echo "Atendido. Recebendo mídia...\n";
        $phone->receiveMedia();
        \Swoole\Coroutine::sleep(10);
    });

    $phone->onReceiveAudio(function ($pcmData, $peer, trunkController $phone) {
        echo "Recebido: " . strlen($pcmData) . " bytes\n";
    });

    $phone->onHangup(function (trunkController $phone) {
        echo "Chamada finalizada\n";
        $phone->close();
    });

    $phone->call('5511999999999');
});

Referência (onde esse exemplo está documentado): https://github.com/spechshop/libspech/blob/spech/README.md

Referência do exemplo completo: https://github.com/spechshop/libspech/blob/spech/example.php

O que está acontecendo aqui? Você registra no servidor SIP, configura callbacks pra cada evento da chamada (ringing, answer, hangup) e, quando atendido, começa a receber chunks de áudio PCM. Cada callback roda na sua própria coroutine, sem travar nada.

6) Três exercícios práticos (pra você realmente aprender fazendo)

Ler código é legal, mas mexer nele é melhor. Aqui vão três experimentos rápidos pra você sentir como tudo funciona:

1) Troque o codec e compare

Mude opus/48000/2 para L16/8000 (o README do libspech também menciona L16/8000) e compare o que você recebe em onReceiveAudio. Você vai notar diferença no tamanho dos chunks e na qualidade do áudio.
Referência: https://github.com/spechshop/libspech/blob/spech/README.md

2) Instrumente o fluxo de PCM

Deixe o log de strlen($pcmData) rodando e observe os padrões: tamanho dos chunks, frequência de chegada, variações (jitter aparente). É fascinante ver como o áudio flui em tempo real.
Referência: https://github.com/spechshop/libspech/blob/spech/README.md

3) Faça a UI reagir aos eventos

O SpechPhone usa um cliente "thin" via WebSocket. Faça o frontend reagir aos eventos "ringing/answered/hangup" que vêm do backend. Comece simples: apenas logando na tela. Depois você pode adicionar animações, indicadores visuais, etc.
Referência: https://github.com/spechshop/spechphone/blob/volume-dev/README.md

Links principais (pra você não se perder)

Aqui estão todos os recursos que você vai precisar:

SpechPhone (repo): https://github.com/spechshop/spechphone
SpechPhone (README, branch volume-dev): https://github.com/spechshop/spechphone/blob/volume-dev/README.md
libspech (repo): https://github.com/spechshop/libspech
libspech (README, branch spech): https://github.com/spechshop/libspech/blob/spech/README.md
libspech (example.php): https://github.com/spechshop/libspech/blob/spech/example.php
pcg729 (runtime release "current/php"): https://github.com/spechshop/pcg729/releases/tag/current

E agora? Clone o repo, suba os servidores e faça sua primeira chamada. Os conceitos apresentados aqui são aplicáveis a qualquer stack que implemente I/O assíncrono com corrotinas. Boa sorte! 🚀