En unos 30 a 45 minutos vas a escribir la parte de Kolo de Kolo Meet, un ejemplo de escritorio para videollamadas. La ventana, hecha con Wails 3 y React, ya está lista, y también la mayor parte del servicio en Go que hay detrás: los estados de la llamada, la red, el notch y la bandeja. Tú escribes las partes que usan Kolo: las cámaras y los micrófonos, la invitación, el relay que ejecuta quien inicia la llamada, tu propia emisión, ver a los demás y las claves de grupo.
Una llamada es cámara, micrófono y nada más: no hay chat, ni mensajes de
texto, ni archivos compartidos. Todo se queda en tu ordenador, en la
dirección 127.0.0.1, y terminas con tres copias de la app en una misma
llamada.
1Comprueba lo que necesitas y abre la ventana
Necesitas Go 1.26 o superior, Node.js con npm, Git y tres ventanas de terminal. Si aún no tienes Go, sigue el primer paso de Construye un chat en tu terminal. Después instala la herramienta de línea de comandos de Wails 3, que compila la app:
go install github.com/wailsapp/wails/v3/cmd/wails3@v3.0.0En Linux, ejecuta wails3 doctor: muestra los paquetes del sistema que
necesita la ventana. Solo la ventana necesita cgo. Las bibliotecas de audio,
vídeo y red son solo Go: para ellas no instalas ningún códec, ninguna
biblioteca de sonido ni ningún compilador.
Descarga el starter:
git clone https://github.com/ciranda-dev/kolo-meet-wails3-starter.git && cd kolo-meet-wails3-starterSu go.mod ya incluye todas las bibliotecas que usas:
kolo-video para las cámaras y VP8,
kolo-audio para micrófonos, altavoces y Opus,
kolo-invite para la invitación,
kolo-moq para el relay y las claves, y
kolo-media v0.1.0 para las emisiones, con
kolo-swarm, kolo-dht
y kolo-secure por debajo.
Compílala. La primera compilación tarda unos minutos, porque el códec de vídeo es un paquete de Go grande; las siguientes usan la caché de Go. En macOS puede que veas avisos del enlazador sobre la versión de macOS; no afectan.
wails3 buildEjecútala con su propia carpeta de datos. -first hace que esta ventana
ejecute el primer nodo de entrada de una red pequeña en 127.0.0.1:4000, la
dirección a la que las otras ventanas preguntan primero para encontrarse.
Es solo para pruebas locales: el Kolo Meet terminado usa la red pública por
defecto, y -bootstrap lo apunta a un nodo de entrada propio.
./bin/kolo-meet -data "$(mktemp -d)/ana" -first 127.0.0.1:4000$dir = New-Item -ItemType Directory -Path (Join-Path $env:TEMP "kolo-meet-$(Get-Random)")
.\bin\kolo-meet.exe -data (Join-Path $dir.FullName "ana") -first 127.0.0.1:4000./bin/kolo-meet -data "$(mktemp -d)/ana" -first 127.0.0.1:4000Cuando la red está lista, el terminal muestra la clave de la app entre las líneas que imprime Wails. Tu hora y tu clave serán distintas:
2026/11/16 09:53:02 kolo-id c7865ee7c063ed613ff06f2f24a706bc192e07e560dce797a7a5aef01d63ada7La ventana te pide un nombre: escribe uno y pulsa Continuar. Pulsa Iniciar
una llamada: la sala de espera muestra la vista previa de la cámara, el
medidor del micrófono y los selectores de dispositivos. Los dispositivos son
inventados por el starter, en starter.go: enciende la cámara y verás rayas
grises en movimiento, enciende el micrófono y el medidor se mueve cada medio
segundo. Todavía no se abre nada real. Pulsa Iniciar llamada: la llamada
termina al momento con "No se pudo iniciar la llamada: not implemented in the
starter (step 3 of the guide)." Cada parte que escribes lo dice hasta que la
escribas.
Esto es lo que escribes, y dónde. Cada función ya está en el starter, como
un stub que devuelve ErrNotInStarter, así que la app siempre compila:
| Paso | Archivo | Lo que escribes |
|---|---|---|
| 2 | hw.go | listar y abrir cámaras, micrófonos y altavoces, y sus errores |
| 3 | host.go, member.go, publisher.go | el relay y la invitación, entrar en la llamada, tu pista de audio |
| 4 | guest.go, member.go, remote.go | unirse con una invitación, ver a los demás, decodificar lo que envían |
| 5 | member.go | las claves de grupo: quién recibe la tuya y cómo recibes las de los demás |
Los pasos 7 y 8 no añaden código: muestran dos partes que el starter ya tiene, el informe de calidad de la llamada y el ritmo de imágenes.
2Dispositivos y vista previa en la sala de espera
El servicio solo llega a la máquina a través de la interfaz hardware de
hw.go. La versión de la app es kolo-video y kolo-audio; las pruebas usan
dispositivos inventados, así que una prueba nunca abre una cámara, un
micrófono o un altavoz reales. Listar tampoco abre ningún dispositivo, así
que nunca pide permiso: solo lo hace encender un dispositivo, y apagarlo lo
cierra, así que la luz de "en uso" del sistema se apaga.
En hw.go, sustituye el bloque de imports por:
import (
"context"
"errors"
"io/fs"
koloaudio "github.com/ciranda-dev/kolo-audio"
kolovideo "github.com/ciranda-dev/kolo-video"
)Después sustituye todo desde // realHardware is hasta el final del archivo
por los tres bloques de abajo, pegados uno tras otro.
// realHardware is kolo-video and kolo-audio on the machine.
type realHardware struct{}
func list[T any](ds []T, err error, conv func(T) Device) ([]Device, error) {
out := []Device{}
for _, d := range ds {
out = append(out, conv(d))
}
if errors.Is(err, kolovideo.ErrNoDevice) || errors.Is(err, kolovideo.ErrUnsupported) ||
errors.Is(err, koloaudio.ErrNoDevice) || errors.Is(err, koloaudio.ErrUnsupported) {
return out, nil
}
return out, err
}
func (realHardware) Cameras() ([]Device, error) {
ds, err := kolovideo.Devices()
return list(ds, err, func(d kolovideo.Device) Device { return Device{ID: d.ID, Name: d.Name, Default: d.Default} })
}
func audioDevices(kind koloaudio.Kind) ([]Device, error) {
ds, err := koloaudio.Devices(kind)
return list(ds, err, func(d koloaudio.Device) Device { return Device{ID: d.ID, Name: d.Name, Default: d.Default} })
}
func (realHardware) Microphones() ([]Device, error) { return audioDevices(koloaudio.Capture) }
func (realHardware) Speakers() ([]Device, error) { return audioDevices(koloaudio.Playback) }kolovideo.Devices y koloaudio.Devices listan lo que está conectado.
ErrNoDevice y ErrUnsupported no son errores aquí: un ordenador sin cámara
recibe una lista vacía y aun así puede unirse a una llamada para escuchar.
func (realHardware) MicrophoneAccess() (string, error) {
a, err := koloaudio.AccessStatus()
if err != nil {
return "", err
}
switch a {
case koloaudio.AccessNotDetermined:
return micNotDetermined, nil
case koloaudio.AccessRestricted:
return micRestricted, nil
case koloaudio.AccessDenied:
return micDenied, nil
case koloaudio.AccessAuthorized:
return micAuthorized, nil
}
return "", koloaudio.ErrBackend
}
func (realHardware) RequestMicrophone(ctx context.Context) error { return koloaudio.RequestAccess(ctx) }
func (realHardware) RequestCamera(ctx context.Context) error { return kolovideo.RequestAccess(ctx) }
func (realHardware) OpenCamera(id string, w, h int, fps float64) (cameraStream, error) {
c, err := kolovideo.OpenCapture(kolovideo.CaptureConfig{DeviceID: id, Width: w, Height: h, FrameRate: fps})
if err != nil {
return nil, err
}
return c, nil
}
func (realHardware) OpenMicrophone(id string) (micStream, error) {
in, err := koloaudio.OpenInput(koloaudio.Config{DeviceID: id, Format: koloaudio.Format{SampleRate: sampleRate, Channels: audioChannels}})
if err != nil {
return nil, err
}
return in, nil
}
func (realHardware) OpenSpeaker(id string) (speakerStream, error) {
out, err := koloaudio.OpenOutput(koloaudio.Config{DeviceID: id, Format: koloaudio.Format{SampleRate: sampleRate, Channels: audioChannels}})
if err != nil {
return nil, err
}
return out, nil
}OpenCapture y OpenInput nunca piden permiso. RequestCamera y
RequestMicrophone sí: en macOS, kolovideo.RequestAccess y
koloaudio.RequestAccess muestran el aviso del sistema la primera vez, y en
Linux y Windows vuelven al momento. MicrophoneAccess solo lee el permiso del
micrófono (koloaudio.AccessStatus), así el lobby sabe de un rechazo antes de
abrir ningún dispositivo. El audio va a 48 kHz, mono, en tramas de 20 ms, los
valores por defecto de kolo-audio.
// deviceError turns an error of kolo-video or kolo-audio into the MeetError of a device kind ("camera",
// "microphone" or "speaker").
func deviceError(kind string, err error) *MeetError {
var me *MeetError
switch {
case err == nil:
return nil
case errors.As(err, &me):
return me
case errors.Is(err, kolovideo.ErrPermission), errors.Is(err, koloaudio.ErrPermission), errors.Is(err, fs.ErrPermission):
return meetErr(kind+"-denied", err, "")
case errors.Is(err, kolovideo.ErrNoDevice), errors.Is(err, koloaudio.ErrNoDevice),
errors.Is(err, kolovideo.ErrUnsupported), errors.Is(err, koloaudio.ErrUnsupported):
return meetErr(kind+"-none", err, "")
case errors.Is(err, kolovideo.ErrDeviceLost), errors.Is(err, koloaudio.ErrDeviceLost):
return meetErr(kind+"-lost", err, "")
}
return meetErr(kind+"-failed", err, "")
}deviceError da a cada fallo su propia frase: un rechazo es
kolovideo.ErrPermission para la cámara, koloaudio.ErrPermission para el
micrófono, o un error que coincide con fs.ErrPermission, así que la ventana
puede decir dónde permitirlo. Un dispositivo que falta y uno perdido también tienen su frase.
Por si un sistema da silencio en lugar de un error, la app también lo avisa
cuando el micrófono envía solo ceros durante 4 segundos.
El starter ya carga el códec de vídeo al arrancar (loadCodecs en
meetservice.go): el VP8 de kolo-video es libvpx, como biblioteca incluida
en el módulo o como el mismo código traducido a Go, y guarda la biblioteca en
la carpeta de datos.
Comprueba que las pruebas siguen usando solo dispositivos inventados y vuelve a compilar:
go test ./...
wails3 buildAbre la ventana otra vez, como en el paso 1. Los selectores ahora muestran tus dispositivos reales. En macOS, la primera vez que enciendes la cámara o el micrófono, el sistema pide permiso. Si se rechaza, la ventana lo dice, y puedes seguir con lo que quede: una llamada sin cámara, o sin ninguno de los dos, sigue siendo una llamada.
3Inicia una llamada: la invitación, el relay y tu emisión
Quien inicia una llamada es el anfitrión. La app del anfitrión ejecuta el relay de la llamada: un relay de kolo-moq con su propia identidad, en su propio nodo de la red. El audio y el vídeo de todos pasan por él. La invitación la sirve un segundo nodo de la red, con una segunda identidad: cualquiera que tenga la invitación puede llegar a ese nodo, mientras que el nodo del relay solo deja entrar a las personas que el anfitrión aceptó. Así, una conexión que pide unirse nunca es una que lleva audio o vídeo.
En host.go, sustituye el bloque de imports por:
import (
"bytes"
"crypto/ed25519"
"crypto/rand"
"encoding/hex"
"errors"
"net/netip"
"strconv"
kolodht "github.com/ciranda-dev/kolo-dht"
koloid "github.com/ciranda-dev/kolo-id"
invite "github.com/ciranda-dev/kolo-invite"
kolomoq "github.com/ciranda-dev/kolo-moq"
kolosecure "github.com/ciranda-dev/kolo-secure"
kolostore "github.com/ciranda-dev/kolo-store"
koloswarm "github.com/ciranda-dev/kolo-swarm"
kolotransport "github.com/ciranda-dev/kolo-transport"
)Sustituye startHost por los cuatro bloques de abajo, pegados uno tras otro.
func (c *call) startHost() error {
s := c.svc
sw := s.swarm()
if sw == nil {
return meetErr("network-not-ready", ErrNotReady, "")
}
relID, err := koloid.Generate()
if err != nil {
return err
}
roomID, seed := make([]byte, 16), make([]byte, 32)
rand.Read(roomID)
rand.Read(seed)
c.mu.Lock()
c.relID = relID.PublicKey()
c.room = &room{id: hex.EncodeToString(roomID), topic: roomTopic(seed), relay: relID.PublicKey(), host: c.me,
hostName: s.displayName(), max: s.maxParticipants()}
c.mu.Unlock()
set := s.settingsCopy()
payload, err := encodeGrant(c.room.id, seed, c.room.relay, c.me, c.room.hostName, c.room.max, relayKeys(set.relays))
if err != nil {
return err
}Una identidad nueva para el relay, un ID de sala aleatorio y una semilla. El grant es lo que recibe cada invitado cuando el anfitrión lo deja entrar: la sala, la semilla, la clave del relay, el anfitrión y las claves de los relays de conexión del anfitrión, así se avisa a un invitado que no tiene ninguno de ellos en su lista. La semilla nunca viaja en claro: la red solo ve el topic que se deriva de ella.
if c.relay, err = kolomoq.NewRelay(&kolomoq.RelayConfig{Session: kolomoq.Config{Authorize: c.relayAuthorize}, Resume: reconnectWindow}); err != nil {
return err
}
if c.ln, err = kolosecure.Listen(c.ctx, "127.0.0.1:0", relID, &kolosecure.Config{Transport: transportConfig()}); err != nil {
return err
}
c.spawn(func() {
for {
conn, err := c.ln.Accept(c.ctx)
if err != nil {
return
}
if bytes.Equal(conn.RemotePublicKey(), c.me) {
c.spawn(func() { c.relay.NewServer(c.ctx, conn) })
continue
}
c.spawn(func() { c.serveConn(conn, conn.RemotePublicKey()) })
}
})relayAuthorize, que ya está en el starter, es la regla del relay: el
RoomPolicy de kolo-moq (solo un miembro puede anunciar un namespace dentro
de la sala, y solo el suyo), y un invitado sin sitio en la llamada se rechaza
al momento. isMember dice a quién dejó entrar el anfitrión mientras la
llamada tiene sitio. El relay también escucha en una dirección de loopback para la sesión
del propio anfitrión. El relay guarda el sitio de un invitado cuya conexión se
perdió durante reconnectWindow, 60 segundos (RelayConfig.Resume), así que
nadie ve salir al invitado mientras se reconecta. La conexión del propio
anfitrión va directa al relay; cualquier otra va a serveConn, que guarda la
sesión del invitado bajo su clave para que el anfitrión pueda quitarlo después.
// The invite is served under a key of its own on a swarm any peer may reach; the call's relay only to the people
// let in, so that a stranger never holds a connection with the stream budget of a person in the call.
invID, err := koloid.Generate()
if err != nil {
return err
}
if c.rsw, err = c.openSwarm(set, swarmCallRelay, relID, c.relayAllow); err != nil {
return err
}
if err := c.rsw.Join(c.ctx, c.room.topic, &koloswarm.JoinOptions{Announce: true}); err != nil {
return meetErr("call-unavailable", err, "")
}
c.spawn(c.relayLoop)El comentario dice por qué hay dos nodos. Una persona en la llamada puede abrir hasta 1000 streams en una conexión, porque cada suscripción y cada grupo de objetos usa un stream, y el transporte fija ese límite cuando la conexión empieza. Un desconocido que pide unirse necesita un stream, así que el nodo de la invitación mantiene el valor por defecto de kolo-transport, 16, y un desconocido nunca tiene una conexión con el margen de una persona de la llamada.
openSwarm, que ya está en el starter, abre un nodo de la red con una
identidad y lo conecta a la red: los nodos de entrada, los relays de conexión
de -relay, así un invitado que no llega al nodo directamente llega a través
de un relay que ambos tengan en su lista, y el ajuste de transporte de
swarmTransport. relayAllow deja entrar en el nodo del relay solo a las
personas que el anfitrión aceptó, y a las que bloqueó, para poder decírselo;
nunca a la propia app del anfitrión. El nodo del relay anuncia el topic de la
sala, así los invitados lo encuentran, y relayLoop entrega al relay cada
invitado que se conecta.
if c.isw, err = c.openSwarm(set, swarmCallInvite, invID, c.inviteAllow); err != nil {
return err
}
db := kolostore.NewMemory()
c.invDB = db
if c.inv, err = invite.Open(db, invID, nil); err != nil {
return err
}
c.spawn(func() {
if err := c.inv.Announce(c.ctx, c.isw); err != nil && c.ctx.Err() == nil && !errors.Is(err, invite.ErrClosed) {
c.logf("invite announce: %v", err)
}
})
c.spawn(c.inviteSwarmLoop)
c.grant = payload
if _, err := c.newInvite(); err != nil {
return err
}
c.spawn(c.inviteLoop)
if err := sw.Join(c.ctx, c.room.topic, nil); err != nil {
return meetErr("call-unavailable", err, "")
}
conn, err := kolosecure.Dial(c.ctx, c.ln.Addr().String(), s.id, relID.PublicKey(), &kolosecure.Config{Transport: transportConfig()})
if err != nil {
return meetErr("relay-unreachable", err, "")
}
return c.enter(conn)
}El segundo nodo usa la identidad de la invitación y acepta a cualquiera menos
a la propia app del anfitrión (inviteAllow). kolo-invite guarda sus
registros en kolo-store, aquí solo en memoria, y se anuncia en ese nodo;
inviteSwarmLoop responde allí a cada petición para unirse. Después el
anfitrión entra en su propia llamada: se conecta al listener de loopback del
relay y llama a enter, como cualquier otro participante.
Sustituye newInvite por:
// newInvite makes an invite for the call and keeps its code as the one the window shows. The earlier invites keep
// working until they expire or the call ends.
func (c *call) newInvite() (string, error) {
if c.inv == nil {
return "", ErrNoCall
}
infos, err := c.inv.List()
if err != nil {
return "", err
}
active := 0
for _, i := range infos {
if i.State == invite.Active {
active++
}
}
if active >= maxCallInvites {
return "", meetErr("too-many-invites", ErrBusy, strconv.Itoa(maxCallInvites))
}
code, _, err := c.inv.Create(&invite.CreateOptions{TTL: inviteTTL, MaxUses: maxInviteUses, Manual: true})
if err != nil {
return "", err
}
c.mu.Lock()
c.inviteStr = code
c.mu.Unlock()
c.changed()
return code, nil
}Una invitación dura 24 horas y la responde la app del anfitrión (Manual),
que comprueba que la llamada tiene sitio. La invitación es un secreto: quien
la tiene puede pedir unirse. Nunca va al historial, a los logs, a la bandeja
ni al notch.
Ahora la emisión. En member.go, sustituye el bloque de imports por:
import (
"bytes"
"context"
"crypto/ed25519"
"encoding/hex"
"errors"
"fmt"
"slices"
"sync"
"time"
kolomedia "github.com/ciranda-dev/kolo-media"
kolomoq "github.com/ciranda-dev/kolo-moq"
"github.com/ciranda-dev/kolo-moq/secobj"
kolotransport "github.com/ciranda-dev/kolo-transport"
)Sustituye enter por:
// enter makes this person a participant: its protected broadcast, its keys, its session to the relay of the call,
// the roster and the media. conn is a connection to the relay.
func (c *call) enter(conn kolomoq.Conn) error {
s := c.svc
var err error
if c.origin, err = kolomoq.NewOrigin(nil); err != nil {
return err
}
ns := c.room.memberNS(c.me)
if c.sender, err = secobj.NewSender(c.origin, ns, nil); err != nil {
return err
}
if c.bc, err = kolomedia.NewSecureBroadcast(c.origin, c.sender); err != nil {
return err
}
if c.keys, err = secobj.NewKeyring(secobj.KeyringConfig{Authorize: c.keyOwner, Relays: c.roomRelays()}); err != nil {
return err
}
c.mu.Lock()
c.pub = newPublisher(c.bc, c.sender, s.vid, &c.others)
c.mu.Unlock()
profile, err := c.origin.CreateTrack(ns, profileTrack, &kolomoq.TrackOptions{Priority: kolomoq.DefaultPriority, CacheGroups: 1})
if err != nil {
return err
}
c.profile = profile
if err := c.attach(conn); err != nil {
return err
}
c.mix = newMixer(nil)
c.spawn(c.superviseRelay)
c.spawn(c.rosterLoop)
c.spawn(c.publishProfiles)
c.spawn(c.expirePendingLoop)
c.spawn(c.runSpeaker)
c.spawn(c.adaptLoop)
c.spawn(c.watchdogLoop)
c.spawn(c.qualityLoop)
mic, _ := s.media.isOpen()
if err := c.pub.setAudio(mic); err != nil {
return err
}
s.media.setSink(&sinks{audio: c.pub.onAudio, video: c.pub.onVideo})
return nil
}enter es donde una persona pasa a ser participante, anfitrión o invitado.
El Origin guarda lo que publicas. El Sender tiene tu clave para tu
namespace, y NewSecureBroadcast crea una emisión de kolo-media en la que
cada objeto, el catálogo incluido, va sellado con ella. El Keyring guardará
las claves de los demás (paso 5). Tu sesión con el relay solo deja que el
relay lea tu emisión, y PublishNamespace la anuncia allí: cuando ese
anuncio vuelve, la llamada está activa.
attach es la parte de enter que crea la sesión y anuncia la emisión, una
función aparte para que la llamada pueda repetirla. superviseRelay abre una
sesión nueva cuando la anterior termina, e intenta durante hasta 60 segundos
con esperas que se duplican de 0,5 s a 4 s, y conserva a tus personas,
dispositivos y el estado de silencio. watchdogLoop hace lo mismo cuando una
persona que envía no entrega nada durante 6 segundos, un camino que deja pasar
los datagramas pequeños y descarta los grandes. adaptLoop mueve la cámara por
una escalera de calidad, 360p, 720p y el techo de 1080p, según lo que lleva la
conexión con el relay: baja al momento cuando la cola es vieja y sube tras 4
segundos de camino despejado. qualityLoop añade lo que envías al informe
de calidad de la llamada cada 5 segundos (paso 7). Estas ayudas ya están en el
starter, en reconnect.go, watchdog.go, adapt.go, ladder.go y
quality.go, así que no las escribes.
La pista de vídeo ya está en el starter (onVideo en publisher.go).
Escribe la pista de audio: en publisher.go, sustituye setAudio por:
// setAudio adds or removes the microphone track.
func (p *publisher) setAudio(on bool) error {
p.amu.Lock()
defer p.amu.Unlock()
if p.closed || (on == (p.audio != nil)) {
return nil
}
if !on {
err := p.audio.Close()
p.audio = nil
p.aenc.Close()
p.aenc = nil
return err
}
enc, err := opus.NewEncoder(audioEncoderConfig())
if err != nil {
return meetErr("codec-unavailable", err, "")
}
if audioComplexity >= 0 {
enc.SetComplexity(audioComplexity)
}
tp, err := p.b.AddTrack(audioTrackDef(), kolomedia.PackagerOptions{})
if err != nil {
enc.Close()
return err
}
if p.lossPct > 0 {
setLoss(enc, p.lossPct)
}
ts, _ := p.clock.At(time.Now(), sampleRate)
p.audio, p.aenc, p.abase, p.asamples = tp, enc, ts, 0
return nil
}Una pista solo existe mientras su dispositivo está encendido, así que
silenciar la quita, y los demás ven "micrófono apagado" en tu catálogo
sellado. El audio es Opus a 32 kbit/s constantes, así que el tamaño de los
paquetes no revela cuándo hablas. El codificador del micrófono tiene un cerrojo
propio (amu), así que nunca espera a una trama de cámara que se está
codificando, y la app activa la corrección de errores hacia delante de Opus
(setLoss) mientras el camino pierde grupos.
Sustituye onAudio por una constante y la función:
// audioResync is how far the timeline of the microphone's frames may fall behind the clock before it jumps forward to
// it: the playout delay a receiver needs at least (kolo-media's PlayoutConfig.MinDelay), so ordinary jitter of the
// microphone's thread stays inside it.
const audioResync = 100 * time.Millisecond
// onAudio encodes one 20 ms frame of the microphone. Timestamps count samples, so they never jitter, and the timeline
// follows the clock of the video: a microphone that delivers fewer frames than the clock counts (its thread starved, or
// the device overran) moves it forward by the frames lost, a gap the receiver makes up, instead of letting it fall behind
// without end, which the receiver's playout, measuring arrival against these timestamps with the video's, takes for a
// lateness that no delay covers: it drops every audio frame from then on.
func (p *publisher) onAudio(pcm []int16) {
now := time.Now()
p.amu.Lock()
defer p.amu.Unlock()
if p.closed || p.audio == nil {
return
}
out := make([]byte, opus.PacketBufferSize)
n, err := p.aenc.Encode(pcm, out)
if err != nil || n == 0 {
return
}
ts := p.abase + p.asamples
if wall, err := p.clock.At(now, sampleRate); err == nil && wall > ts+uint64(len(pcm))+uint64(audioResync.Seconds()*sampleRate) {
p.abase += (wall - ts - uint64(len(pcm))) / uint64(len(pcm)) * uint64(len(pcm))
ts = p.abase + p.asamples
}
p.asamples += uint64(len(pcm))
if err := p.audio.WriteFrame(kolomedia.Frame{Timestamp: ts, Keyframe: true, Data: out[:n]}); err != nil && !errors.Is(err, kolomedia.ErrClosed) {
return
}
}Cada trama de 20 ms del micrófono se convierte en un paquete Opus y una trama
de la pista. Su marca de tiempo cuenta muestras, así que nunca tiembla. Cuando
el micrófono entrega menos tramas de las que cuenta el reloj, porque su hilo
quedó sin tiempo o el dispositivo se desbordó, la línea de tiempo salta hasta
el reloj en cuanto lleva más de 100 ms de retraso (audioResync). Lo perdido
es entonces un hueco que el receptor compensa, y no audio que se descarta para
siempre.
Vuelve a compilar y abre una ventana como en el paso 1. Inicia una llamada:
la vista de la llamada dice "1 en la llamada, cifrado de extremo a extremo, a
través del relé gestionado por ti", y la vista del anfitrión tiene la
invitación, que empieza con koloinv0. Todavía nadie puede unirse.
4Únete a una llamada y ve a los demás
Un invitado pega la invitación. Su app busca al anfitrión en un topic derivado del secreto de la invitación, pide unirse, recibe el grant sellado solo para él y después se conecta al relay.
En guest.go, sustituye el bloque de imports por:
import (
"context"
"errors"
"time"
invite "github.com/ciranda-dev/kolo-invite"
kolomoq "github.com/ciranda-dev/kolo-moq"
koloswarm "github.com/ciranda-dev/kolo-swarm"
)Sustituye joinHost por:
func (c *call) joinHost() error {
s := c.svc
sw := s.swarm()
if sw == nil {
return meetErr("network-not-ready", ErrNotReady, "")
}
if err := sw.Join(c.ctx, c.code.Topic(), &koloswarm.JoinOptions{Lookup: true}); err != nil {
return meetErr("lookup-failed", err, "")
}
var peer swarmPeer
select {
case peer = <-c.joinPeer:
case <-time.After(s.set.FindTimeout):
sw.Leave(c.code.Topic())
c.mu.Lock()
unreachable := c.noInviter
c.mu.Unlock()
if unreachable {
return hostUnreachable(len(s.set.relays) > 0)
}
return ErrNotFound
case <-c.ctx.Done():
sw.Leave(c.code.Topic())
return c.ctx.Err()
}
c.setPhase(phaseWaitingHost)
actx, cancel := context.WithTimeout(c.ctx, joinAnswerTimeout)
defer cancel()
payload, err := invite.JoinConn(actx, peer.Conn(), s.id, c.code, nil)
sw.Leave(c.code.Topic()) // the invite-only connection closes; the call gets its own
if err != nil {
return err
}
r, err := parseGrant(payload)
if err != nil {
return err
}
mine := s.settingsCopy().relays
c.mu.Lock()
c.room = r
c.relayShare = shareRelay(mine, r.relayKeys)
c.warning = relayMismatch(mine, r.relayKeys)
c.mu.Unlock()
if !c.move(callConnecting, phaseRelay) {
return context.Canceled
}
if err := sw.Join(c.ctx, r.topic, nil); err != nil {
return meetErr("lookup-failed", err, "")
}
select {
case rp := <-c.relayPeer:
kind, via := s.linkOf(rp.Conn())
c.mu.Lock()
c.relayLink, c.relayVia = kind, via
c.mu.Unlock()
conn := rp.Conn()
if h := relayHook; h != nil {
conn = h(c, conn)
}
return c.enter(conn)
case <-time.After(s.set.FindTimeout):
c.mu.Lock()
defer c.mu.Unlock()
return relayWaitReason(c.noRelay, c.relayShare)
case <-c.ctx.Done():
return c.ctx.Err()
}
}La invitación lleva una huella de la clave de la invitación y un secreto,
nunca una dirección. JoinConn pide entrar en el nodo de la invitación del
anfitrión y espera la respuesta. parseGrant, que ya está en el starter,
comprueba que la respuesta es un grant y rechaza todo lo que esté mal
formado. La clave de la invitación nunca es la del relay, así que el invitado
solo conoce la clave del relay por el grant, sellado solo para él. Las demás
ayudas también están en el starter:
hostUnreachable dice cuándo se encontró al anfitrión pero no se pudo llegar a
él, ni directamente ni a través de los relays de conexión, y relayMismatch
avisa a un invitado cuyos relays de conexión no comparten ninguno con los del
anfitrión.
En member.go, sustituye watchLoop por:
// watchLoop plays p's broadcast through the relay. Watch returns once a catalog that opens under p's key arrives,
// so until the key is here the person is "waiting for keys" and nothing of it plays.
func (c *call) watchLoop(p *participant) {
caps := watchCapabilities()
for p.ctx.Err() == nil {
w, err := kolomedia.Watch(p.ctx, c.session(), p.ns, kolomedia.WatchOptions{Capabilities: caps, Keys: c.keys, RequestKeyframes: !noKeyRequests})
if err != nil {
c.mu.Lock()
p.watchErr = err
c.mu.Unlock()
if !sleep(p.ctx, retryEvery) {
return
}
continue
}
c.setPState(p, partLive)
c.playWatcher(p, w)
w.Close()
if p.ctx.Err() != nil {
return
}
c.mu.Lock()
p.audioOn, p.videoOn = false, false
c.mu.Unlock()
c.setPState(p, partStopped)
if !sleep(p.ctx, retryEvery) {
return
}
c.setPState(p, partWaitingKeys)
}
}kolomedia.Watch con Keys solo vuelve cuando llega un catálogo que se abre
con la clave del emisor. Hasta entonces la persona está "esperando claves" y
no se reproduce nada suyo. Se ejecuta sobre c.session(), la sesión actual con
el relay, así que tras una reconexión la escucha empieza de nuevo en la nueva.
RequestKeyframes hace que una escucha pida al emisor un grupo nuevo, que
empieza con un fotograma clave, cuando su pista de vídeo lo espera, como mucho
una vez por segundo, en lugar de esperar al siguiente grupo (hasta 2 s). El
emisor lo atiende con TrackPublisher.KeyframeRequests.
En remote.go, sustituye el bloque de imports por:
import (
"context"
"fmt"
"math"
"sync"
"time"
"github.com/ciranda-dev/kolo-audio/opus"
kolomedia "github.com/ciranda-dev/kolo-media"
"github.com/ciranda-dev/kolo-video/vpx"
)Sustituye playAudio y playVideo por:
func (c *call) playAudio(ctx context.Context, p *participant, w *kolomedia.Watcher) error {
dec, err := opus.NewDecoder(sampleRate, audioChannels)
if err != nil {
return err
}
defer dec.Close()
pcm := make([]int16, int(opus.MaxPacketDuration.Seconds()*sampleRate)*audioChannels)
var speak speakTracker
var g gaps
for {
f, _, err := w.Next(ctx, kolomedia.Audio)
if err != nil {
return err
}
if miss := g.missing(f.Timestamp); miss > 0 && miss <= maxGapFrames {
p.missed.Add(uint64(miss))
if !noConceal {
c.concealGap(p, dec, f.Data, pcm, miss)
}
}
n, err := dec.Decode(f.Data, pcm)
if err != nil || n == 0 {
continue
}
p.audioBytes.Add(uint64(len(f.Data)))
db := pcmLevel(pcm[:n])
now := time.Now()
p.level.Store(math.Float64bits(db))
p.speaking.Store(speak.update(db, now))
p.lastAudio.Store(now.UnixNano())
p.audioIn.Add(1)
c.mix.push(p.id, pcm[:n])
}
}func (c *call) playVideo(ctx context.Context, p *participant, w *kolomedia.Watcher) error {
dec, err := vpx.NewDecoder(remoteDecoderConfig())
if err != nil {
return err
}
defer dec.Close()
tile := tileRenderer{b: &c.svc.tiles, id: p.id}
defer c.svc.tiles.release(p.id)
for {
f, _, err := w.Next(ctx, kolomedia.Video)
if err != nil {
return err
}
began := time.Now()
img, err := dec.Decode(vpx.Packet{Data: f.Data, Keyframe: f.Keyframe})
if err != nil || img == nil {
continue
}
now := time.Now()
p.noteDecode(now.Sub(began))
p.videoIn.Add(1)
p.videoBytes.Add(uint64(len(f.Data)))
p.videoSize.Store(uint64(img.Width)<<32 | uint64(img.Height))
if ev, ok := tile.render(img, now); ok {
ev.ID = p.id
c.svc.emit("meet:frame", ev)
p.videoShown.Add(1)
p.freeze.picture(now)
}
}
}El audio va al mezclador, que reproduce a todos en tu altavoz; el volumen
mueve el anillo de quien habla. El vídeo se decodifica y se dibuja en un JPEG
pequeño para el recuadro de la ventana. Una trama que no se decodifica se
salta hasta el siguiente fotograma clave. Las tramas que no llegaron se cuentan
(gaps), y hasta 3 seguidas se rellenan: ocultación de pérdidas de Opus y, para
la última, la corrección de errores hacia delante del paquete siguiente. Cada
trama también suma a los contadores del informe de calidad de la llamada (paso
7): los bytes recibidos, el tamaño de la imagen, el tiempo que tardó en
decodificarse, las imágenes mostradas y freeze, que nota cuándo se paran las
imágenes.
Vuelve a compilar. En la Terminal 1, abre el anfitrión como en el paso 1. En la Terminal 2, abre una segunda ventana que se une a la red de la primera:
./bin/kolo-meet -data "$(mktemp -d)/bruno" -bootstrap 127.0.0.1:4000$dir = New-Item -ItemType Directory -Path (Join-Path $env:TEMP "kolo-meet-$(Get-Random)")
.\bin\kolo-meet.exe -data (Join-Path $dir.FullName "bruno") -bootstrap 127.0.0.1:4000./bin/kolo-meet -data "$(mktemp -d)/bruno" -bootstrap 127.0.0.1:4000Inicia una llamada en la primera ventana y copia la invitación. En la segunda, pulsa Unirme con una invitación, pégala, pulsa Continuar y después Unirme. Cada ventana tiene ahora un recuadro para la otra persona, el recuadro dice "Esperando claves" y la cabecera cuenta "1 esperando claves": ni imagen ni sonido. Faltan hasta los nombres: los recuadros muestran "Guest" y el principio de la clave de la otra persona, porque los nombres también viajan sellados. Es así a propósito. El audio y el vídeo llegan sellados al relay, y nadie le ha dado todavía una clave a nadie.
5Claves de grupo
Cada participante sella su emisión con su propia clave y se la da a cada uno de los demás por la conexión entre los dos, directa o a través de un relay de conexión que ambos tengan en su lista, nunca a través del relay de la llamada. Cuando alguien entra o sale, la clave del emisor cambia, así que quien se fue no puede leer nada sellado después de irse.
En member.go, sustituye keyOwner por:
// keyOwner is the Keyring's rule: a peer gives the key of its own namespace, and only while it is in the call.
func (c *call) keyOwner(peer ed25519.PublicKey, ns kolomoq.Namespace) error {
if !c.room.owns(peer, ns) {
return errors.New("kolo-meet: not the owner of that namespace")
}
c.mu.Lock()
defer c.mu.Unlock()
if c.people[hex.EncodeToString(peer)] == nil {
return errors.New("kolo-meet: not in the call")
}
return nil
}Es la regla del Keyring: un peer puede dar la clave de su propio
namespace, y solo mientras está en la llamada.
Sustituye updateMembers por:
// updateMembers gives our key to everyone in the call, rotating it when the set changed.
func (c *call) updateMembers() {
if c.sender == nil {
return
}
c.memberMu.Lock()
defer c.memberMu.Unlock()
c.mu.Lock()
keys := make([]ed25519.PublicKey, 0, len(c.people))
for _, p := range c.people {
keys = append(keys, p.key)
}
c.mu.Unlock()
c.others.Store(int32(len(keys)))
if err := c.sender.SetMembers(keys); err != nil && c.ctx.Err() == nil {
c.logf("set members: %v", err)
}
}SetMembers fija quién recibe tu clave. Cuando el conjunto cambia, el
Sender crea una clave nueva, la envía a la pista de claves de cada miembro
antes de usarla y cierra la pista de quien se fue. La ventana muestra
entonces "NOMBRE ya no recibe tu audio ni tu vídeo".
Sustituye startLink por:
// startLink makes the media session between us and p on their own connection, and fetches p's key on it.
func (c *call) startLink(p *participant, peer swarmPeer) {
c.spawn(func() {
lctx, cancel := context.WithCancel(p.ctx)
cfg := &kolomoq.Config{Origin: c.origin, Authorize: c.pairAuthorize, SetupTimeout: pendingTTL}
var sess *kolomoq.Session
var err error
if bytes.Compare(c.me, p.key) < 0 {
sess, err = kolomoq.NewClient(lctx, peer.Conn(), cfg)
} else {
sess, err = kolomoq.NewServer(lctx, peer.Conn(), cfg)
}
if err != nil {
cancel()
return
}
l := &link{peer: peer, sess: sess, cancel: cancel}
l.kind, l.via = c.svc.linkOf(peer.Conn())
if old := c.setLink(p, l, nil); old != nil {
old.stop()
}
if c.svc.holdKeys != nil && c.svc.holdKeys(p.key) {
return
}
for {
err := c.keys.Receive(lctx, sess, c.me, p.ns)
c.mu.Lock()
p.keyErr, p.keyTries = err, p.keyTries+1
c.mu.Unlock()
select {
case <-lctx.Done():
return
case <-sess.Done():
return
case <-time.After(retryEvery):
}
}
})
}La conexión entre dos participantes lleva una sesión de kolo-moq.
pairAuthorize, que ya está en el starter, rechaza en ella toda petición
salvo la pista de claves hecha para quien la pide, así que por ahí no se
sirve audio ni vídeo. Receive instala las claves de la otra persona a
medida que llegan; holdKeys es un gancho que usan las pruebas para simular
a alguien cuya clave nunca llega, y en la app es nil.
Vuelve a compilar y abre otra vez las dos ventanas del paso 4. En más o menos un segundo, los recuadros pasan de "Esperando claves" al nombre, la imagen y el sonido de la otra persona, y la cabecera de la ventana del anfitrión dice "2 en la llamada, cifrado de extremo a extremo, a través del relé gestionado por ti".
Lo que esto protege, tal como lo dice la ventana al abrir la cabecera: el relay no puede ver el audio, el vídeo ni los nombres, ni siquiera cuánto mide un nombre. El relay ve quién está en la llamada, quién ve a quién, cuándo envía cada persona y cuánto, cuándo están apagados los micrófonos y las cámaras, y el ID de la sala; puede descartar o retrasar el audio y el vídeo. Cualquiera en la llamada puede leer el audio y el vídeo de todos. Cualquiera en la llamada podría, con ayuda del relay, crear audio, vídeo o nombres que parezcan venir de otra persona, y el anfitrión, que gestiona el relay, podría hacerlo solo: cada participante tiene la clave de cada emisor, y los objetos no van firmados por emisor. No hay protección para el periodo de clave actual si un dispositivo queda comprometido, ni recuperación después de un compromiso.
Un participante cuya clave no ha llegado no reproduce nada: no hay
reproducción sin claves. Las claves solo viajan por la conexión entre dos
participantes, nunca a través del relay de la llamada. Esa conexión es
directa, o pasa por un relay de conexión que los dos indican con -relay.
Una pareja que no puede conectarse de ninguna de las dos formas sigue
mostrando "Esperando claves". El AES-GCM de Go es de tiempo constante solo en procesadores amd64
y arm64 con instrucciones AES, ppc64x y s390x.
6Ejecuta tres copias en un mismo ordenador
Ya están escritos todos los stubs, así que los archivos propios del starter
sobran. Borra starter.go y starter_test.go: ya nada los usa. Después
comprueba tu código con las pruebas del ejemplo terminado. Arrancan de dos a
cuatro copias del servicio en un solo proceso, con dispositivos inventados,
en 127.0.0.1, y comprueban que todos ven y oyen a todos, el silencio, la
cámara apagada, la salida, una llamada llena y un participante cuya clave
nunca llega. Tardan uno o dos minutos:
go vet -tags finished .
go test -tags finished .
wails3 buildAbre tres ventanas. La Terminal 1 es el anfitrión y ejecuta el primer nodo de entrada; la Terminal 2 y la Terminal 3 se unen a su red:
./bin/kolo-meet -data "$(mktemp -d)/ana" -first 127.0.0.1:4000
./bin/kolo-meet -data "$(mktemp -d)/bruno" -bootstrap 127.0.0.1:4000
./bin/kolo-meet -data "$(mktemp -d)/carla" -bootstrap 127.0.0.1:4000$dir = New-Item -ItemType Directory -Path (Join-Path $env:TEMP "kolo-meet-$(Get-Random)")
.\bin\kolo-meet.exe -data (Join-Path $dir.FullName "ana") -first 127.0.0.1:4000
.\bin\kolo-meet.exe -data (Join-Path $dir.FullName "bruno") -bootstrap 127.0.0.1:4000
.\bin\kolo-meet.exe -data (Join-Path $dir.FullName "carla") -bootstrap 127.0.0.1:4000./bin/kolo-meet -data "$(mktemp -d)/ana" -first 127.0.0.1:4000
./bin/kolo-meet -data "$(mktemp -d)/bruno" -bootstrap 127.0.0.1:4000
./bin/kolo-meet -data "$(mktemp -d)/carla" -bootstrap 127.0.0.1:4000Ejecuta cada línea en su propio terminal (en Windows, ejecuta la primera
línea en cada terminal antes de su línea de kolo-meet). Inicia una llamada
en la ventana de Ana y envía la invitación a los otros dos: la misma
invitación sirve para ambos. La cuadrícula muestra tres personas, con sus
nombres y un anillo alrededor de quien habla. Las tres copias comparten tu
única cámara y tu único micrófono, así que usa auriculares o silencia dos de
ellas, o los altavoces se cuelan en el micrófono.
Prueba a silenciar y a apagar la cámara: el recuadro cambia para los demás. Cuando Bruno pulsa Salir, los demás ven "Bruno ya no recibe tu audio ni tu vídeo", y las claves cambian. Cuando Ana, la anfitriona, termina la llamada, termina para todos y se dice por qué: el relay era suyo.
7Mira cómo va la llamada
Mientras una llamada está en curso, cada ventana escribe un informe de calidad
de la llamada: cada 5 segundos, una línea JSON por cada persona que ves
("kind":"remote") y una por lo que envías ("kind":"local"). El archivo es
kolo-meet-quality.jsonl, en la carpeta de datos, y solo tú puedes leerlo
(modo 0600); al llegar a 2 MiB pasa a ser kolo-meet-quality.jsonl.1 y empieza
uno nuevo. Solo guarda cuentas, tamaños y tiempos, nunca un nombre, una clave,
una invitación, una dirección ni audio o vídeo. Cuando una ventana arranca, su
terminal dice adónde va el informe, en una línea que empieza por
call quality report is on. -quality-report off lo desactiva, y
-quality-log además escribe cada línea en la terminal, después de
quality:.
En este paso no escribes nada: el informe está en quality.go, y sus
contadores los añadiste en los pasos 3 y 4. Aquí se ve de dónde salen sus
números. Para cada persona que ves, logMedia, que ya está en el starter,
llama a reportRemote cada 5 segundos:
// reportRemote writes the quality record of p for the interval since q0 and returns the counters it read.
func (c *call) reportRemote(p *participant, st kolomedia.WatchStats, q0 peerCounters, secs float64, now time.Time) peerCounters {
q := p.counters(st)
if !c.svc.qualityOn() {
return q
}
r := remoteRecord(q0, q, secs)
r.At, r.T, r.Call, r.Person = now.Unix(), round1(now.Sub(c.began).Seconds()), c.id, p.person
size := p.videoSize.Load()
r.VideoW, r.VideoH = int(size>>32), int(size&0xffffffff)
n, longest := p.freeze.take(now)
r.Freezes, r.FreezeLongestMs = n, longest.Milliseconds()
r.PlayoutDelayMs, r.PlayoutJitterMs = st.Playout.Delay.Milliseconds(), st.Playout.Jitter.Milliseconds()
r.DecodeMs = ms(time.Duration(p.decodeNs.Load()))
rate, cost := c.svc.tiles.display(p.id)
r.DisplayFPS, r.TileMs = rate, ms(cost)
c.svc.reportQuality(r)
return q
}
// counters reads the totals of p's watch for the quality record: the playout's drops come from st.
func (p *participant) counters(st kolomedia.WatchStats) peerCounters {
dropped := func(t kolomedia.TrackStats) uint64 { return t.Late + t.Skipped + t.Overflow }
return peerCounters{
audioIn: p.audioIn.Load(), missed: p.missed.Load(), concealed: p.concealed.Load(), audioDropped: dropped(st.Playout.Tracks["audio"]),
videoIn: p.videoIn.Load(), shown: p.videoShown.Load(), videoDropped: dropped(st.Playout.Tracks["video"]),
audioBytes: p.audioBytes.Load(), videoBytes: p.videoBytes.Load(),
}
}Watcher.Stats de kolo-media dice lo que vio la recepción de una persona: el
retardo del búfer de jitter y cuánto tarde llegan las tramas
(Playout.Delay y Playout.Jitter) y, para cada pista, las tramas que
descartó porque llegaron demasiado tarde, se saltaron o no cabían en el búfer.
Los contadores que añadiste en playAudio y playVideo dan el resto. Una
congelación es una parada de más de 500 ms entre dos imágenes mientras la
cámara de la persona está encendida.
Para lo que envías, qualityLoop lee Stats de cada una de tus sesiones con
el relay (un anfitrión tiene una por invitado) y las suma:
// sentStats is what the sessions of the sender showed at one reading, by session: counters restart with a session.
type sentStats map[*kolomoq.Session]kolomoq.SessionStats
// sinceLast adds up what each session carried since prev, and the oldest queue among them.
func (cur sentStats) sinceLast(prev sentStats) (sent, reset, expired uint64, queue time.Duration) {
for s, st := range cur {
p := prev[s]
sent += sub(st.SentBytes, p.SentBytes)
reset += sub(st.ResetGroups, p.ResetGroups)
expired += sub(st.ExpiredGroups, p.ExpiredGroups)
queue = max(queue, st.QueueDelay)
}
return sent, reset, expired, queue
}
// net is the transport's view of the sessions that report it, since prev; nil when none does. A session of a connection
// without statistics, such as one through a connection relay, has an empty controller name and is left out.
func (cur sentStats) net(prev sentStats) *qualityNet {
var worst *kolomoq.SessionStats
var sent, lost uint64
for s, st := range cur {
if st.Transport.CongestionController == "" {
continue
}
p := prev[s].Transport
sent += sub(st.Transport.PacketsSent, p.PacketsSent)
lost += sub(st.Transport.PacketsLost, p.PacketsLost)
if worst == nil || st.Transport.SmoothedRTT > worst.Transport.SmoothedRTT {
worst = &st
}
}
if worst == nil {
return nil
}
t := worst.Transport
n := &qualityNet{
RTTMs: ms(t.SmoothedRTT), MinRTTMs: ms(t.MinRTT), RTTVarMs: ms(t.RTTVariation),
CwndBytes: t.CongestionWindow, InFlightByte: t.BytesInFlight, Controller: t.CongestionController,
BwKbps: round1(float64(t.BandwidthEstimate) * 8 / 1000), PathChanges: t.PathChanges,
}
if sent > 0 {
n.LossPct = round1(float64(min(lost, sent)) * 100 / float64(sent))
}
return n
}SessionStats de kolo-moq tiene los bytes enviados, los grupos de objetos
abandonados (reiniciados porque la cola estaba llena, o caducados porque eran
demasiado viejos) y cuánto espera el objeto más antiguo sin enviar: más de
250 ms es un camino lleno. Su parte Transport es lo que kolo-transport midió
en la conexión: el tiempo de ida y vuelta, los paquetes perdidos, la ventana de
congestión y el nombre del control de congestión. El objeto net de la línea
local se queda con la sesión de mayor tiempo de ida y vuelta. Una sesión a
través de un relay de conexión no tiene esos números, así que se deja fuera.
El control es reno salvo que abras la app con -congestion cubic o
-congestion bbr. Una llamada envía menos de lo que lleva el camino, y bbr
mantiene una cola de 25 a 150 ms, así que reno es el valor por defecto; los
otros dos están para comparar en un camino con pérdidas, con este informe.
8Elige cuántas imágenes por segundo
La ventana no decodifica vídeo: el servicio en Go decodifica las tramas de
cada persona y dibuja cada imagen en un JPEG pequeño para su recuadro
(tile.render en playVideo). Dibujar usa tiempo de procesador, así que la
app elige cuántas imágenes por segundo dibuja cada recuadro. -display-fps
lo fija: auto, el valor por defecto, 30 o 15. En este paso tampoco
escribes nada: la regla está en tiles.go.
// The display rates, in pictures a second of one tile, and the rule that picks one.
const (
// tileRateHigh is the rate while at most tileFewRemote other people show video: kolo-video's default capture rate,
// so every picture sent is shown.
tileRateHigh = kolovideo.DefaultFrameRate
// tileRateLow is the rate with more people, and while the guard finds the drawing too costly: half of it.
tileRateLow = kolovideo.DefaultFrameRate / 2
tileFewRemote = 4
// tileCPUMax is the share of one core the JPEG work of all tiles may take at tileRateHigh before the rate falls to
// tileRateLow; it goes back up when that work is under tileCPUResume, so a load near the limit does not flip the rate.
tileCPUMax = 0.5
tileCPUResume = 0.4
// tileCostWeight is the weight of each new picture in a tile's mean cost, and tileCostWarm the pictures a tile
// needs before its cost counts.
tileCostWeight = 0.1
tileCostWarm = 5
// tileEarly is how long before its turn a frame is still taken: camera frames are not evenly spaced, and at
// tileRateHigh a frame that came a millisecond early would cost a whole interval.
tileEarly = 8 * time.Millisecond
// tileByteRateLow bounds the bytes a second of picture events over all tiles at tileRateLow. Wails parks an event
// over 8 KiB until the webview fetches it, at most 64 MiB in all, each for 30 s plus up to a sweep of 7.5 s, and
// sends what does not fit inline, which keeps memory on macOS (wails v3.0.0 pkg/application/event_payload_store.go:33-57,
// webview_window.go:1459-1475). At this rate even a webview that fetches nothing never fills the store; the budget
// grows with the rate (tileByteRate), so at tileRateHigh such a webview fills it in half the time.
tileByteRateLow = (64 << 20) * 4 / (30 * 5)
// selfTile is the ID of the tile of our own camera.
selfTile = "self"
)
// -display-fps values. Auto is the rule above; the other two fix the rate and switch the guard off.
const (
displayAuto = "auto"
display30 = "30"
display15 = "15"
)// rateLocked is the rate tiles draw at now: the fixed one of -display-fps 30 or 15, else tileRateHigh with at most
// tileFewRemote other people showing video, unless the guard holds it at tileRateLow, else tileRateLow.
func (b *tileBudget) rateLocked() int {
switch b.mode {
case display30:
return tileRateHigh
case display15:
return tileRateLow
}
remote := len(b.live)
if _, ok := b.live[selfTile]; ok {
remote--
}
if remote > tileFewRemote {
return tileRateLow
}
if noTileGuard {
return tileRateHigh
}
var work float64
warm := true
for _, t := range b.live {
work += t.cost.Seconds() * tileRateHigh
warm = warm && t.n >= tileCostWarm
}
switch {
case !warm:
case b.guarded && work < tileCPUResume:
b.guarded = false
case !b.guarded && work > tileCPUMax:
b.guarded = true
}
if b.guarded {
return tileRateLow
}
return tileRateHigh
}Con auto, cada recuadro dibuja 30 imágenes por segundo, el ritmo de
captura por defecto de kolo-video, así que se muestra cada imagen enviada,
mientras como mucho 4 personas más muestran vídeo, y 15 con más. Una
protección lleva una media móvil de cuánto tarda en dibujarse y comprimirse
una imagen, para cada recuadro. Cuando dibujar todos los recuadros a 30
llevaría más de la mitad de un núcleo del procesador, dibujan a 15 hasta que
baja del 40%, así una carga cerca del límite no hace que el ritmo salte de un
valor a otro. 30 y 15 fijan el ritmo y desactivan la protección.
Para probarlo, abre una ventana más como en el paso 6, con su propia carpeta
de datos y -display-fps 15 al final de la línea, y únete a la llamada de Ana
con la misma invitación. Cada recuadro de esa ventana, también el de su propia
cámara, dibuja 15 imágenes por segundo, y su informe lo dice: display_mode es
15 en las líneas local, y las líneas remote tienen display_fps 15 junto a
tile_ms, el tiempo que tarda en dibujarse una imagen.
Qué acaba de pasar
- Cada ventana encontró a las demás a través del nodo de entrada que ejecutó la primera. La app del anfitrión ejecutó el relay de la llamada, y cada emisión pasó por él. La subida del anfitrión lleva el audio y el vídeo de cada participante a todos los demás.
- La invitación llevó a los invitados hasta el nodo de la invitación del anfitrión, y la app del anfitrión los dejó entrar mientras la llamada tenía sitio. Solo entonces conocieron la identidad del relay, por el grant.
- Cada objeto de cada emisión iba sellado con la clave de su emisor, y las claves viajaron por la conexión directa entre cada pareja, nunca a través del relay. Consulta kolo-media y kolo-moq.
Próximos pasos
- Lee la página de kolo-media: emisiones, visionado y medios protegidos, con sus límites.
- Lee cómo funciona una invitación en Invita a alguien a un grupo, en un programa de terminal.
- El código terminado de este ejemplo está en el repositorio
kolo-meet-wails3-example de la organización ciranda-dev. Sin
starter.go, tus archivos Go son los mismos.