168 lines
8.0 KiB
PHP
168 lines
8.0 KiB
PHP
<?php
|
|
|
|
use Blax\WebRtc\Authorization\DefaultRoomAuthorizer;
|
|
use Blax\WebRtc\Events\NullCallEventListener;
|
|
use Blax\WebRtc\Media\NullMediaEngine;
|
|
use Blax\WebRtc\Rooms\Stores\ArrayRoomStore;
|
|
|
|
return [
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| Signaling bind
|
|
|--------------------------------------------------------------------------
|
|
| Where the signaling server (on the shared ReactPHP kernel) listens. For
|
|
| browser clients you will typically front this with the laravel-websockets
|
|
| WS transport instead; this raw endpoint drives + tests the media engine.
|
|
*/
|
|
'host' => env('WEBRTC_HOST', '127.0.0.1'),
|
|
'port' => (int) env('WEBRTC_PORT', 8090),
|
|
|
|
// ReactPHP TLS context; leave both unset for plain TCP.
|
|
'tls' => array_filter([
|
|
'local_cert' => env('WEBRTC_TLS_CERT'),
|
|
'local_pk' => env('WEBRTC_TLS_KEY'),
|
|
]),
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| Media engine
|
|
|--------------------------------------------------------------------------
|
|
| The backend that terminates media (ICE/DTLS/SRTP/RTP/Opus), records, and
|
|
| bridges to external realtime providers. NullMediaEngine = signaling only
|
|
| (peer-to-peer mesh); RustMediaEngine = BACKEND-HOSTED rooms on the Rust
|
|
| SFU sidecar (plug-and-play — see the `sfu` block below).
|
|
*/
|
|
'media_engine' => env('WEBRTC_MEDIA_ENGINE', NullMediaEngine::class),
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| Rust SFU sidecar (RustMediaEngine)
|
|
|--------------------------------------------------------------------------
|
|
| The `blax-webrtc-sfu` binary from this package's rust/ directory: one
|
|
| process per host that terminates ICE/DTLS/SRTP and forwards audio between
|
|
| room peers (no decoding), records Ogg/Opus per peer, and reports usage.
|
|
|
|
|
| Plug-and-play defaults: the first RustMediaEngine call DOWNLOADS the
|
|
| checksummed prebuilt binary for this platform (auto_install) and SPAWNS
|
|
| it detached, flock-guarded (auto_spawn). For supervised deployments run
|
|
| `php artisan webrtc:sidecar` as a service and disable auto_spawn.
|
|
|
|
|
| udp_port 0 = ephemeral (fine same-host); pin it (and publish it on the
|
|
| container) for production, and set public_ip to the address browsers
|
|
| can reach — it is advertised in the ICE host candidate.
|
|
*/
|
|
'sfu' => [
|
|
'socket' => env('WEBRTC_SFU_SOCKET', storage_path('app/webrtc/sfu.sock')),
|
|
'udp_ip' => env('WEBRTC_SFU_UDP_IP', '0.0.0.0'),
|
|
'udp_port' => (int) env('WEBRTC_SFU_UDP_PORT', 0),
|
|
'public_ip' => env('WEBRTC_SFU_PUBLIC_IP'),
|
|
|
|
'auto_spawn' => (bool) env('WEBRTC_SFU_AUTO_SPAWN', true),
|
|
'auto_install' => (bool) env('WEBRTC_SFU_AUTO_INSTALL', true),
|
|
'spawn_timeout' => (float) env('WEBRTC_SFU_SPAWN_TIMEOUT', 10),
|
|
'log' => env('WEBRTC_SFU_LOG', storage_path('logs/webrtc-sfu.log')),
|
|
|
|
// Binary resolution: explicit path > local rust/target build > install.
|
|
'binary' => env('WEBRTC_SFU_BINARY'),
|
|
'install_path' => env('WEBRTC_SFU_INSTALL_PATH', storage_path('app/webrtc/bin')),
|
|
'version' => env('WEBRTC_SFU_VERSION'), // default: the version pinned by this package
|
|
'download_url' => env(
|
|
'WEBRTC_SFU_DOWNLOAD_URL',
|
|
'https://git.blax.at/blax-software/laravel-webrtc/releases/download/{version}/blax-webrtc-sfu-{platform}',
|
|
),
|
|
// sha256 verification is REQUIRED when set; null opts out explicitly.
|
|
'checksum_url' => env(
|
|
'WEBRTC_SFU_CHECKSUM_URL',
|
|
'https://git.blax.at/blax-software/laravel-webrtc/releases/download/{version}/blax-webrtc-sfu-{platform}.sha256',
|
|
),
|
|
],
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| Recording (store the full call audio)
|
|
|--------------------------------------------------------------------------
|
|
| When enabled, the browser streams its mic to the server as binary WS frames
|
|
| and RelaySignalingHandler appends them per participant via a RecordingStore
|
|
| (FileRecordingStore by default: <path>/<room>/<peer>.<format>). See README.
|
|
*/
|
|
'recording' => [
|
|
'enabled' => (bool) env('WEBRTC_RECORDING', false),
|
|
'path' => env('WEBRTC_RECORDING_PATH', storage_path('app/webrtc')),
|
|
'format' => env('WEBRTC_RECORDING_FORMAT', 'webm'),
|
|
],
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| Backend-defined rooms (the room registry)
|
|
|--------------------------------------------------------------------------
|
|
| The rooms clients are allowed to join. A join to anything NOT listed here is
|
|
| rejected — clients can't invent rooms. Each room configures its transport:
|
|
| 'p2p' — browsers mesh, the server only relays signaling (no server media)
|
|
| 'sfu' — the server terminates media (the Rust SFU; enables recording/scale)
|
|
|
|
|
| Shapes (all equivalent granularity):
|
|
| 'just-talk' => 'p2p',
|
|
| 'lobby' => ['mode' => 'sfu', 'limit' => 50, 'type' => 'presence'],
|
|
| 'private-desk' => ['mode' => 'p2p'], // membership type inferred from prefix
|
|
|
|
|
| For DYNAMIC rooms (created/edited at runtime), point `room_registry` at your
|
|
| own Contracts\RoomRegistry (e.g. an Eloquent-backed one); the static `rooms`
|
|
| map below is the fallback used when no registry class is bound.
|
|
*/
|
|
'room_registry' => env('WEBRTC_ROOM_REGISTRY'),
|
|
|
|
'rooms' => [],
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| Room authorization + call-event log
|
|
|--------------------------------------------------------------------------
|
|
| `authorizer` gates private-* / presence-* joins (bind your own that checks a
|
|
| token / the authenticated user; the default DENIES them). `events` receives
|
|
| call-lifecycle events so you can log the call (bind your own to persist).
|
|
*/
|
|
'authorizer' => env('WEBRTC_AUTHORIZER', DefaultRoomAuthorizer::class),
|
|
'events' => env('WEBRTC_EVENTS', NullCallEventListener::class),
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| Room membership store
|
|
|--------------------------------------------------------------------------
|
|
| Where room membership + presence lives. The default ArrayRoomStore keeps it
|
|
| in process memory (right for the long-lived bundled server). A fork-per-
|
|
| message host (a classic Laravel WebSocket handling each frame in a fresh
|
|
| worker) binds a Cache/Redis-backed RoomStore so state survives across
|
|
| workers — that is how a host runs this relay on its existing WS.
|
|
*/
|
|
'room_store' => env('WEBRTC_ROOM_STORE', ArrayRoomStore::class),
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| ICE servers (STUN/TURN) advertised to browsers
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
'ice_servers' => [
|
|
// ['urls' => 'stun:stun.l.google.com:19302'],
|
|
// ['urls' => 'turn:turn.example.com:3478', 'username' => '...', 'credential' => '...'],
|
|
],
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| External realtime bridge (provider hidden from the browser)
|
|
|--------------------------------------------------------------------------
|
|
| OpenAiRealtimeBridge (or the media engine) dials these; the browser only ever
|
|
| talks to us, so the AI provider is invisible and the model is swappable
|
|
| server-side. `instructions` is the persona (the host injects its own — e.g.
|
|
| an ATC prompt) and `voice` the spoken voice.
|
|
*/
|
|
'bridge' => [
|
|
'openai' => [
|
|
'endpoint' => env('WEBRTC_OPENAI_ENDPOINT', 'wss://api.openai.com/v1/realtime'),
|
|
'model' => env('WEBRTC_OPENAI_MODEL', 'gpt-realtime'),
|
|
'api_key' => env('OPENAI_API_KEY'),
|
|
'voice' => env('WEBRTC_OPENAI_VOICE', 'alloy'),
|
|
'instructions' => null,
|
|
],
|
|
],
|
|
];
|