kolo docsbeta

Construye una videollamada

Un tutorial paso a paso. Completa la parte de Kolo de una ventana de escritorio ya hecha: cámaras y micrófonos, una invitación, un relay que ejecuta el anfitrión y claves de grupo que ocultan al relay el audio, el vídeo y los nombres.

En esta página

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:

Terminal
go install github.com/wailsapp/wails/v3/cmd/wails3@v3.0.0

En 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:

Terminal
git clone https://github.com/ciranda-dev/kolo-meet-wails3-starter.git && cd kolo-meet-wails3-starter

Su 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.

Terminal
wails3 build

Ejecú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.

bash
./bin/kolo-meet -data "$(mktemp -d)/ana" -first 127.0.0.1:4000

Cuando 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:

Texto
2026/11/16 09:53:02 kolo-id c7865ee7c063ed613ff06f2f24a706bc192e07e560dce797a7a5aef01d63ada7

La 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:

PasoArchivoLo que escribes
2hw.golistar y abrir cámaras, micrófonos y altavoces, y sus errores
3host.go, member.go, publisher.goel relay y la invitación, entrar en la llamada, tu pista de audio
4guest.go, member.go, remote.gounirse con una invitación, ver a los demás, decodificar lo que envían
5member.golas 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:

hw.go
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.

hw.go
// 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.

hw.go
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.

hw.go
// 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:

Terminal
go test ./...
wails3 build

Abre 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:

host.go
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.

host.go
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.

host.go
	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.

host.go
	// 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.

host.go
	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:

host.go
// 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:

member.go
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:

member.go
// 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:

publisher.go
// 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:

publisher.go
// 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:

guest.go
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:

guest.go
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:

member.go
// 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:

remote.go
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:

remote.go
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])
	}
}
remote.go
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:

bash
./bin/kolo-meet -data "$(mktemp -d)/bruno" -bootstrap 127.0.0.1:4000

Inicia 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:

member.go
// 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:

member.go
// 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:

member.go
// 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:

Terminal
go vet -tags finished .
go test -tags finished .
wails3 build

Abre 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:

bash
./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

Ejecuta 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:

remote.go
// 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:

quality.go
// 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.

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"
)
tiles.go
// 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.