feat: Phase 3 — crypto handshake, codec2, benchmarks, audio I/O, relay forwarding
E2E crypto handshake: - Client/relay handshake via SignalMessage (CallOffer/CallAnswer) - X25519 ephemeral key exchange with Ed25519 identity signatures - Integration tests proving bidirectional encrypt/decrypt Codec2 integration: - Pure Rust codec2 crate (v0.3) — no C bindings needed - MODE_3200 (160 samples/20ms, 8 bytes) and MODE_1200 (320 samples/40ms, 6 bytes) - 11 new tests including encode/decode roundtrip and adaptive switching Relay forwarding: - Bidirectional client → remote forwarding with pipeline processing - CLI args: --listen, --remote - Periodic stats logging, clean shutdown via tokio::select! Benchmark tool (wzp-bench): - Codec roundtrip, FEC recovery, crypto throughput, full pipeline benchmarks - Sine wave PCM generator for realistic testing Audio I/O (cpal): - AudioCapture (microphone) and AudioPlayback (speakers) at 48kHz mono - CLI --live mode: mic → encode → send / recv → decode → speakers 120 tests passing, 0 failures. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Siavash Sameni
467
Cargo.lock
generated
467
Cargo.lock
generated
@@ -12,6 +12,37 @@ dependencies = [
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "1.1.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "alsa"
|
||||
version = "0.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed7572b7ba83a31e20d1b48970ee402d2e3e0537dcfe0a3ff4d6eb7508617d43"
|
||||
dependencies = [
|
||||
"alsa-sys",
|
||||
"bitflags 2.11.0",
|
||||
"cfg-if",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "alsa-sys"
|
||||
version = "0.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"pkg-config",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "anyhow"
|
||||
version = "1.0.102"
|
||||
@@ -49,6 +80,12 @@ dependencies = [
|
||||
"pkg-config",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
version = "1.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
|
||||
|
||||
[[package]]
|
||||
name = "base64"
|
||||
version = "0.22.1"
|
||||
@@ -61,6 +98,30 @@ version = "1.8.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
|
||||
|
||||
[[package]]
|
||||
name = "bindgen"
|
||||
version = "0.72.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
|
||||
dependencies = [
|
||||
"bitflags 2.11.0",
|
||||
"cexpr",
|
||||
"clang-sys",
|
||||
"itertools",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"regex",
|
||||
"rustc-hash",
|
||||
"shlex",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "2.11.0"
|
||||
@@ -95,6 +156,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
|
||||
dependencies = [
|
||||
"find-msvc-tools",
|
||||
"jobserver",
|
||||
"libc",
|
||||
"shlex",
|
||||
]
|
||||
|
||||
@@ -104,6 +167,15 @@ version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
|
||||
|
||||
[[package]]
|
||||
name = "cexpr"
|
||||
version = "0.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
|
||||
dependencies = [
|
||||
"nom",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.4"
|
||||
@@ -151,6 +223,17 @@ dependencies = [
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "clang-sys"
|
||||
version = "1.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
|
||||
dependencies = [
|
||||
"glob",
|
||||
"libc",
|
||||
"libloading",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cmake"
|
||||
version = "0.1.58"
|
||||
@@ -160,6 +243,12 @@ dependencies = [
|
||||
"cc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "codec2"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2cefd04ca4a2f096acf5f44da5e5931436d030a620901f1fe8fa773e6b9de65b"
|
||||
|
||||
[[package]]
|
||||
name = "combine"
|
||||
version = "4.6.7"
|
||||
@@ -192,6 +281,49 @@ version = "0.8.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
|
||||
|
||||
[[package]]
|
||||
name = "coreaudio-rs"
|
||||
version = "0.11.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "321077172d79c662f64f5071a03120748d5bb652f5231570141be24cfcd2bace"
|
||||
dependencies = [
|
||||
"bitflags 1.3.2",
|
||||
"core-foundation-sys",
|
||||
"coreaudio-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "coreaudio-sys"
|
||||
version = "0.2.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ceec7a6067e62d6f931a2baf6f3a751f4a892595bcec1461a3c94ef9949864b6"
|
||||
dependencies = [
|
||||
"bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cpal"
|
||||
version = "0.15.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "873dab07c8f743075e57f524c583985fbaf745602acbe916a01539364369a779"
|
||||
dependencies = [
|
||||
"alsa",
|
||||
"core-foundation-sys",
|
||||
"coreaudio-rs",
|
||||
"dasp_sample",
|
||||
"jni",
|
||||
"js-sys",
|
||||
"libc",
|
||||
"mach2",
|
||||
"ndk",
|
||||
"ndk-context",
|
||||
"oboe",
|
||||
"wasm-bindgen",
|
||||
"wasm-bindgen-futures",
|
||||
"web-sys",
|
||||
"windows",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cpufeatures"
|
||||
version = "0.2.17"
|
||||
@@ -239,6 +371,12 @@ dependencies = [
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "dasp_sample"
|
||||
version = "0.11.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
|
||||
|
||||
[[package]]
|
||||
name = "der"
|
||||
version = "0.7.10"
|
||||
@@ -294,6 +432,12 @@ dependencies = [
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.15.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
|
||||
|
||||
[[package]]
|
||||
name = "equivalent"
|
||||
version = "1.0.2"
|
||||
@@ -334,6 +478,30 @@ version = "0.1.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
|
||||
|
||||
[[package]]
|
||||
name = "futures-core"
|
||||
version = "0.3.32"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
|
||||
|
||||
[[package]]
|
||||
name = "futures-task"
|
||||
version = "0.3.32"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
|
||||
|
||||
[[package]]
|
||||
name = "futures-util"
|
||||
version = "0.3.32"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
|
||||
dependencies = [
|
||||
"futures-core",
|
||||
"futures-task",
|
||||
"pin-project-lite",
|
||||
"slab",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "generic-array"
|
||||
version = "0.14.7"
|
||||
@@ -371,6 +539,12 @@ dependencies = [
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "glob"
|
||||
version = "0.3.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
|
||||
|
||||
[[package]]
|
||||
name = "hashbrown"
|
||||
version = "0.16.1"
|
||||
@@ -414,6 +588,15 @@ dependencies = [
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
@@ -464,6 +647,16 @@ dependencies = [
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "jobserver"
|
||||
version = "0.1.34"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
|
||||
dependencies = [
|
||||
"getrandom 0.3.4",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "js-sys"
|
||||
version = "0.3.91"
|
||||
@@ -486,6 +679,16 @@ version = "0.2.183"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
|
||||
|
||||
[[package]]
|
||||
name = "libloading"
|
||||
version = "0.8.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libm"
|
||||
version = "0.2.16"
|
||||
@@ -513,12 +716,27 @@ version = "0.1.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
|
||||
|
||||
[[package]]
|
||||
name = "mach2"
|
||||
version = "0.4.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
|
||||
dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
|
||||
|
||||
[[package]]
|
||||
name = "minimal-lexical"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
|
||||
|
||||
[[package]]
|
||||
name = "mio"
|
||||
version = "1.1.1"
|
||||
@@ -530,6 +748,45 @@ dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ndk"
|
||||
version = "0.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2076a31b7010b17a38c01907c45b945e8f11495ee4dd588309718901b1f7a5b7"
|
||||
dependencies = [
|
||||
"bitflags 2.11.0",
|
||||
"jni-sys 0.3.1",
|
||||
"log",
|
||||
"ndk-sys",
|
||||
"num_enum",
|
||||
"thiserror 1.0.69",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ndk-context"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
|
||||
|
||||
[[package]]
|
||||
name = "ndk-sys"
|
||||
version = "0.5.0+25.2.9519653"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691"
|
||||
dependencies = [
|
||||
"jni-sys 0.3.1",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "nom"
|
||||
version = "7.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
"minimal-lexical",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "nu-ansi-term"
|
||||
version = "0.50.3"
|
||||
@@ -545,6 +802,71 @@ version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967"
|
||||
|
||||
[[package]]
|
||||
name = "num-derive"
|
||||
version = "0.4.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.19"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num_enum"
|
||||
version = "0.7.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
|
||||
dependencies = [
|
||||
"num_enum_derive",
|
||||
"rustversion",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num_enum_derive"
|
||||
version = "0.7.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
|
||||
dependencies = [
|
||||
"proc-macro-crate",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "oboe"
|
||||
version = "0.6.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e8b61bebd49e5d43f5f8cc7ee2891c16e0f41ec7954d36bcb6c14c5e0de867fb"
|
||||
dependencies = [
|
||||
"jni",
|
||||
"ndk",
|
||||
"ndk-context",
|
||||
"num-derive",
|
||||
"num-traits",
|
||||
"oboe-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "oboe-sys"
|
||||
version = "0.6.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6c8bb09a4a2b1d668170cfe0a7d5bc103f8999fb316c98099b6a9939c9f2e79d"
|
||||
dependencies = [
|
||||
"cc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "once_cell"
|
||||
version = "1.21.4"
|
||||
@@ -644,6 +966,15 @@ dependencies = [
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro-crate"
|
||||
version = "3.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
|
||||
dependencies = [
|
||||
"toml_edit 0.25.8+spec-1.1.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.106"
|
||||
@@ -809,9 +1140,38 @@ version = "0.5.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"bitflags 2.11.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "1.12.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-automata",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-automata"
|
||||
version = "0.4.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
|
||||
dependencies = [
|
||||
"aho-corasick",
|
||||
"memchr",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
version = "0.8.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
|
||||
|
||||
[[package]]
|
||||
name = "ring"
|
||||
version = "0.17.14"
|
||||
@@ -951,7 +1311,7 @@ version = "3.7.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"bitflags 2.11.0",
|
||||
"core-foundation",
|
||||
"core-foundation-sys",
|
||||
"libc",
|
||||
@@ -1245,8 +1605,8 @@ checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_spanned",
|
||||
"toml_datetime",
|
||||
"toml_edit",
|
||||
"toml_datetime 0.6.11",
|
||||
"toml_edit 0.22.27",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1258,6 +1618,15 @@ dependencies = [
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "toml_datetime"
|
||||
version = "1.1.0+spec-1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "97251a7c317e03ad83774a8752a7e81fb6067740609f75ea2b585b569a59198f"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "toml_edit"
|
||||
version = "0.22.27"
|
||||
@@ -1267,9 +1636,30 @@ dependencies = [
|
||||
"indexmap",
|
||||
"serde",
|
||||
"serde_spanned",
|
||||
"toml_datetime",
|
||||
"toml_datetime 0.6.11",
|
||||
"toml_write",
|
||||
"winnow",
|
||||
"winnow 0.7.15",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "toml_edit"
|
||||
version = "0.25.8+spec-1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "16bff38f1d86c47f9ff0647e6838d7bb362522bdf44006c7068c2b1e606f1f3c"
|
||||
dependencies = [
|
||||
"indexmap",
|
||||
"toml_datetime 1.1.0+spec-1.1.0",
|
||||
"toml_parser",
|
||||
"winnow 1.0.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "toml_parser"
|
||||
version = "1.1.0+spec-1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2334f11ee363607eb04df9b8fc8a13ca1715a72ba8662a26ac285c98aabb4011"
|
||||
dependencies = [
|
||||
"winnow 1.0.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1414,6 +1804,20 @@ dependencies = [
|
||||
"wasm-bindgen-shared",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-futures"
|
||||
version = "0.4.64"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"futures-util",
|
||||
"js-sys",
|
||||
"once_cell",
|
||||
"wasm-bindgen",
|
||||
"web-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro"
|
||||
version = "0.2.114"
|
||||
@@ -1446,6 +1850,16 @@ dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "web-sys"
|
||||
version = "0.3.91"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
|
||||
dependencies = [
|
||||
"js-sys",
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "web-time"
|
||||
version = "1.1.0"
|
||||
@@ -1474,12 +1888,41 @@ dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows"
|
||||
version = "0.54.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9252e5725dbed82865af151df558e754e4a3c2c30818359eb17465f1346a1b49"
|
||||
dependencies = [
|
||||
"windows-core",
|
||||
"windows-targets 0.52.6",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-core"
|
||||
version = "0.54.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "12661b9c89351d684a50a8a643ce5f608e20243b9fb84687800163429f161d65"
|
||||
dependencies = [
|
||||
"windows-result",
|
||||
"windows-targets 0.52.6",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-link"
|
||||
version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
||||
|
||||
[[package]]
|
||||
name = "windows-result"
|
||||
version = "0.1.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
|
||||
dependencies = [
|
||||
"windows-targets 0.52.6",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.45.0"
|
||||
@@ -1711,6 +2154,15 @@ dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winnow"
|
||||
version = "1.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen"
|
||||
version = "0.51.0"
|
||||
@@ -1724,6 +2176,7 @@ dependencies = [
|
||||
"anyhow",
|
||||
"async-trait",
|
||||
"bytes",
|
||||
"cpal",
|
||||
"tokio",
|
||||
"tracing",
|
||||
"tracing-subscriber",
|
||||
@@ -1731,6 +2184,7 @@ dependencies = [
|
||||
"wzp-crypto",
|
||||
"wzp-fec",
|
||||
"wzp-proto",
|
||||
"wzp-relay",
|
||||
"wzp-transport",
|
||||
]
|
||||
|
||||
@@ -1739,6 +2193,7 @@ name = "wzp-codec"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"audiopus",
|
||||
"codec2",
|
||||
"tracing",
|
||||
"wzp-proto",
|
||||
]
|
||||
|
||||
@@ -34,6 +34,7 @@ raptorq = "2"
|
||||
|
||||
# Codec
|
||||
audiopus = "0.3.0-rc.0"
|
||||
codec2 = "0.3"
|
||||
|
||||
# Crypto
|
||||
x25519-dalek = { version = "2", features = ["static_secrets"] }
|
||||
|
||||
@@ -18,9 +18,19 @@ tracing-subscriber = { workspace = true }
|
||||
async-trait = { workspace = true }
|
||||
bytes = { workspace = true }
|
||||
anyhow = "1"
|
||||
cpal = "0.15"
|
||||
|
||||
[[bin]]
|
||||
name = "wzp-client"
|
||||
path = "src/cli.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "wzp-bench"
|
||||
path = "src/bench_cli.rs"
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { workspace = true }
|
||||
wzp-relay = { path = "../wzp-relay" }
|
||||
wzp-crypto = { workspace = true }
|
||||
wzp-proto = { workspace = true }
|
||||
async-trait = { workspace = true }
|
||||
|
||||
341
crates/wzp-client/src/audio_io.rs
Normal file
341
crates/wzp-client/src/audio_io.rs
Normal file
@@ -0,0 +1,341 @@
|
||||
//! Real audio I/O via `cpal` — microphone capture and speaker playback.
|
||||
//!
|
||||
//! Both structs use 48 kHz, mono, i16 format to match the WarzonePhone codec
|
||||
//! pipeline. Frames are 960 samples (20 ms at 48 kHz).
|
||||
//!
|
||||
//! The cpal `Stream` type is not `Send`, so each struct spawns a dedicated OS
|
||||
//! thread that owns the stream. The public API exposes only `Send + Sync`
|
||||
//! channel handles.
|
||||
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc;
|
||||
use std::sync::Arc;
|
||||
|
||||
use anyhow::{anyhow, Context};
|
||||
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
|
||||
use cpal::{SampleFormat, SampleRate, StreamConfig};
|
||||
use tracing::{info, warn};
|
||||
|
||||
/// Number of samples per 20 ms frame at 48 kHz mono.
|
||||
pub const FRAME_SAMPLES: usize = 960;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// AudioCapture
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Captures microphone input and yields 960-sample PCM frames.
|
||||
///
|
||||
/// The cpal stream lives on a dedicated OS thread; this handle is `Send + Sync`.
|
||||
pub struct AudioCapture {
|
||||
rx: mpsc::Receiver<Vec<i16>>,
|
||||
running: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl AudioCapture {
|
||||
/// Create and start capturing from the default input device at 48 kHz mono.
|
||||
pub fn start() -> Result<Self, anyhow::Error> {
|
||||
let (tx, rx) = mpsc::sync_channel::<Vec<i16>>(64);
|
||||
let running = Arc::new(AtomicBool::new(true));
|
||||
let running_clone = running.clone();
|
||||
|
||||
let (init_tx, init_rx) = mpsc::sync_channel::<Result<(), String>>(1);
|
||||
|
||||
std::thread::Builder::new()
|
||||
.name("wzp-audio-capture".into())
|
||||
.spawn(move || {
|
||||
let result = (|| -> Result<(), anyhow::Error> {
|
||||
let host = cpal::default_host();
|
||||
let device = host
|
||||
.default_input_device()
|
||||
.ok_or_else(|| anyhow!("no default input audio device found"))?;
|
||||
|
||||
info!(device = %device.name().unwrap_or_default(), "using input device");
|
||||
|
||||
let config = StreamConfig {
|
||||
channels: 1,
|
||||
sample_rate: SampleRate(48_000),
|
||||
buffer_size: cpal::BufferSize::Default,
|
||||
};
|
||||
|
||||
let use_f32 = !supports_i16_input(&device)?;
|
||||
|
||||
let buf = Arc::new(std::sync::Mutex::new(
|
||||
Vec::<i16>::with_capacity(FRAME_SAMPLES),
|
||||
));
|
||||
let err_cb = |e: cpal::StreamError| {
|
||||
warn!("input stream error: {e}");
|
||||
};
|
||||
|
||||
let stream = if use_f32 {
|
||||
let buf = buf.clone();
|
||||
let tx = tx.clone();
|
||||
let running = running_clone.clone();
|
||||
device.build_input_stream(
|
||||
&config,
|
||||
move |data: &[f32], _: &cpal::InputCallbackInfo| {
|
||||
if !running.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
let mut lock = buf.lock().unwrap();
|
||||
for &s in data {
|
||||
lock.push(f32_to_i16(s));
|
||||
if lock.len() == FRAME_SAMPLES {
|
||||
let frame = lock.drain(..).collect();
|
||||
let _ = tx.try_send(frame);
|
||||
}
|
||||
}
|
||||
},
|
||||
err_cb,
|
||||
None,
|
||||
)?
|
||||
} else {
|
||||
let buf = buf.clone();
|
||||
let tx = tx.clone();
|
||||
let running = running_clone.clone();
|
||||
device.build_input_stream(
|
||||
&config,
|
||||
move |data: &[i16], _: &cpal::InputCallbackInfo| {
|
||||
if !running.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
let mut lock = buf.lock().unwrap();
|
||||
for &s in data {
|
||||
lock.push(s);
|
||||
if lock.len() == FRAME_SAMPLES {
|
||||
let frame = lock.drain(..).collect();
|
||||
let _ = tx.try_send(frame);
|
||||
}
|
||||
}
|
||||
},
|
||||
err_cb,
|
||||
None,
|
||||
)?
|
||||
};
|
||||
|
||||
stream.play().context("failed to start input stream")?;
|
||||
|
||||
// Signal success to the caller before parking.
|
||||
let _ = init_tx.send(Ok(()));
|
||||
|
||||
// Keep stream alive until stopped.
|
||||
while running_clone.load(Ordering::Relaxed) {
|
||||
std::thread::park_timeout(std::time::Duration::from_millis(200));
|
||||
}
|
||||
drop(stream);
|
||||
Ok(())
|
||||
})();
|
||||
|
||||
if let Err(e) = result {
|
||||
let _ = init_tx.send(Err(e.to_string()));
|
||||
}
|
||||
})?;
|
||||
|
||||
init_rx
|
||||
.recv()
|
||||
.map_err(|_| anyhow!("capture thread exited before signaling"))?
|
||||
.map_err(|e| anyhow!("{e}"))?;
|
||||
|
||||
Ok(Self { rx, running })
|
||||
}
|
||||
|
||||
/// Read the next frame of 960 PCM samples (blocking until available).
|
||||
///
|
||||
/// Returns `None` when the stream has been stopped or the channel is
|
||||
/// disconnected.
|
||||
pub fn read_frame(&self) -> Option<Vec<i16>> {
|
||||
self.rx.recv().ok()
|
||||
}
|
||||
|
||||
/// Stop capturing.
|
||||
pub fn stop(&self) {
|
||||
self.running.store(false, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// AudioPlayback
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Plays PCM frames through the default output device at 48 kHz mono.
|
||||
///
|
||||
/// The cpal stream lives on a dedicated OS thread; this handle is `Send + Sync`.
|
||||
pub struct AudioPlayback {
|
||||
tx: mpsc::SyncSender<Vec<i16>>,
|
||||
running: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl AudioPlayback {
|
||||
/// Create and start playback on the default output device at 48 kHz mono.
|
||||
pub fn start() -> Result<Self, anyhow::Error> {
|
||||
let (tx, rx) = mpsc::sync_channel::<Vec<i16>>(64);
|
||||
let running = Arc::new(AtomicBool::new(true));
|
||||
let running_clone = running.clone();
|
||||
|
||||
let (init_tx, init_rx) = mpsc::sync_channel::<Result<(), String>>(1);
|
||||
|
||||
std::thread::Builder::new()
|
||||
.name("wzp-audio-playback".into())
|
||||
.spawn(move || {
|
||||
let result = (|| -> Result<(), anyhow::Error> {
|
||||
let host = cpal::default_host();
|
||||
let device = host
|
||||
.default_output_device()
|
||||
.ok_or_else(|| anyhow!("no default output audio device found"))?;
|
||||
|
||||
info!(device = %device.name().unwrap_or_default(), "using output device");
|
||||
|
||||
let config = StreamConfig {
|
||||
channels: 1,
|
||||
sample_rate: SampleRate(48_000),
|
||||
buffer_size: cpal::BufferSize::Default,
|
||||
};
|
||||
|
||||
let use_f32 = !supports_i16_output(&device)?;
|
||||
|
||||
// Shared ring of samples the cpal callback drains from.
|
||||
let ring = Arc::new(std::sync::Mutex::new(
|
||||
std::collections::VecDeque::<i16>::with_capacity(FRAME_SAMPLES * 8),
|
||||
));
|
||||
|
||||
// Background drainer: moves frames from the mpsc channel into the ring.
|
||||
{
|
||||
let ring = ring.clone();
|
||||
let running = running_clone.clone();
|
||||
std::thread::Builder::new()
|
||||
.name("wzp-playback-drain".into())
|
||||
.spawn(move || {
|
||||
while running.load(Ordering::Relaxed) {
|
||||
match rx.recv_timeout(std::time::Duration::from_millis(100)) {
|
||||
Ok(frame) => {
|
||||
let mut lock = ring.lock().unwrap();
|
||||
lock.extend(frame);
|
||||
while lock.len() > FRAME_SAMPLES * 16 {
|
||||
lock.pop_front();
|
||||
}
|
||||
}
|
||||
Err(mpsc::RecvTimeoutError::Timeout) => {}
|
||||
Err(mpsc::RecvTimeoutError::Disconnected) => break,
|
||||
}
|
||||
}
|
||||
})?;
|
||||
}
|
||||
|
||||
let err_cb = |e: cpal::StreamError| {
|
||||
warn!("output stream error: {e}");
|
||||
};
|
||||
|
||||
let stream = if use_f32 {
|
||||
let ring = ring.clone();
|
||||
device.build_output_stream(
|
||||
&config,
|
||||
move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
|
||||
let mut lock = ring.lock().unwrap();
|
||||
for sample in data.iter_mut() {
|
||||
*sample = match lock.pop_front() {
|
||||
Some(s) => i16_to_f32(s),
|
||||
None => 0.0,
|
||||
};
|
||||
}
|
||||
},
|
||||
err_cb,
|
||||
None,
|
||||
)?
|
||||
} else {
|
||||
let ring = ring.clone();
|
||||
device.build_output_stream(
|
||||
&config,
|
||||
move |data: &mut [i16], _: &cpal::OutputCallbackInfo| {
|
||||
let mut lock = ring.lock().unwrap();
|
||||
for sample in data.iter_mut() {
|
||||
*sample = lock.pop_front().unwrap_or(0);
|
||||
}
|
||||
},
|
||||
err_cb,
|
||||
None,
|
||||
)?
|
||||
};
|
||||
|
||||
stream.play().context("failed to start output stream")?;
|
||||
|
||||
// Signal success to the caller before parking.
|
||||
let _ = init_tx.send(Ok(()));
|
||||
|
||||
// Keep stream alive until stopped.
|
||||
while running_clone.load(Ordering::Relaxed) {
|
||||
std::thread::park_timeout(std::time::Duration::from_millis(200));
|
||||
}
|
||||
drop(stream);
|
||||
Ok(())
|
||||
})();
|
||||
|
||||
if let Err(e) = result {
|
||||
let _ = init_tx.send(Err(e.to_string()));
|
||||
}
|
||||
})?;
|
||||
|
||||
init_rx
|
||||
.recv()
|
||||
.map_err(|_| anyhow!("playback thread exited before signaling"))?
|
||||
.map_err(|e| anyhow!("{e}"))?;
|
||||
|
||||
Ok(Self { tx, running })
|
||||
}
|
||||
|
||||
/// Write a frame of PCM samples for playback.
|
||||
pub fn write_frame(&self, pcm: &[i16]) {
|
||||
let _ = self.tx.try_send(pcm.to_vec());
|
||||
}
|
||||
|
||||
/// Stop playback.
|
||||
pub fn stop(&self) {
|
||||
self.running.store(false, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Check if the input device supports i16 at 48 kHz mono.
|
||||
fn supports_i16_input(device: &cpal::Device) -> Result<bool, anyhow::Error> {
|
||||
let supported = device
|
||||
.supported_input_configs()
|
||||
.context("failed to query input configs")?;
|
||||
for cfg in supported {
|
||||
if cfg.sample_format() == SampleFormat::I16
|
||||
&& cfg.min_sample_rate() <= SampleRate(48_000)
|
||||
&& cfg.max_sample_rate() >= SampleRate(48_000)
|
||||
&& cfg.channels() >= 1
|
||||
{
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
/// Check if the output device supports i16 at 48 kHz mono.
|
||||
fn supports_i16_output(device: &cpal::Device) -> Result<bool, anyhow::Error> {
|
||||
let supported = device
|
||||
.supported_output_configs()
|
||||
.context("failed to query output configs")?;
|
||||
for cfg in supported {
|
||||
if cfg.sample_format() == SampleFormat::I16
|
||||
&& cfg.min_sample_rate() <= SampleRate(48_000)
|
||||
&& cfg.max_sample_rate() >= SampleRate(48_000)
|
||||
&& cfg.channels() >= 1
|
||||
{
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn f32_to_i16(s: f32) -> i16 {
|
||||
(s.clamp(-1.0, 1.0) * i16::MAX as f32) as i16
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn i16_to_f32(s: i16) -> f32 {
|
||||
s as f32 / i16::MAX as f32
|
||||
}
|
||||
384
crates/wzp-client/src/bench.rs
Normal file
384
crates/wzp-client/src/bench.rs
Normal file
@@ -0,0 +1,384 @@
|
||||
//! Benchmark functions for measuring WarzonePhone protocol performance.
|
||||
//!
|
||||
//! Covers codec roundtrip, FEC recovery, encryption throughput, and the full pipeline.
|
||||
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use wzp_crypto::ChaChaSession;
|
||||
use wzp_fec::{RaptorQFecDecoder, RaptorQFecEncoder};
|
||||
use wzp_proto::traits::{CryptoSession, FecDecoder, FecEncoder};
|
||||
use wzp_proto::QualityProfile;
|
||||
|
||||
use crate::call::{CallConfig, CallDecoder, CallEncoder};
|
||||
|
||||
// ─── Results ────────────────────────────────────────────────────────────────
|
||||
|
||||
/// Results from the codec roundtrip benchmark.
|
||||
#[derive(Debug)]
|
||||
pub struct CodecResult {
|
||||
pub frames: usize,
|
||||
pub total_encode: Duration,
|
||||
pub total_decode: Duration,
|
||||
pub avg_encode_us: f64,
|
||||
pub avg_decode_us: f64,
|
||||
pub frames_per_sec: f64,
|
||||
pub compression_ratio: f64,
|
||||
}
|
||||
|
||||
/// Results from the FEC recovery benchmark.
|
||||
#[derive(Debug)]
|
||||
pub struct FecResult {
|
||||
pub blocks_attempted: usize,
|
||||
pub blocks_recovered: usize,
|
||||
pub recovery_rate_pct: f64,
|
||||
pub total_source_bytes: usize,
|
||||
pub total_repair_bytes: usize,
|
||||
pub overhead_bytes: usize,
|
||||
pub total_time: Duration,
|
||||
}
|
||||
|
||||
/// Results from the crypto benchmark.
|
||||
#[derive(Debug)]
|
||||
pub struct CryptoResult {
|
||||
pub packets: usize,
|
||||
pub total_time: Duration,
|
||||
pub packets_per_sec: f64,
|
||||
pub megabytes_per_sec: f64,
|
||||
pub avg_latency_us: f64,
|
||||
}
|
||||
|
||||
/// Results from the full pipeline benchmark.
|
||||
#[derive(Debug)]
|
||||
pub struct PipelineResult {
|
||||
pub frames: usize,
|
||||
pub total_encode_pipeline: Duration,
|
||||
pub total_decode_pipeline: Duration,
|
||||
pub avg_e2e_latency_us: f64,
|
||||
pub pcm_bytes_in: usize,
|
||||
pub wire_bytes_out: usize,
|
||||
pub overhead_ratio: f64,
|
||||
}
|
||||
|
||||
// ─── Helpers ────────────────────────────────────────────────────────────────
|
||||
|
||||
/// Generate a sine wave as 16-bit PCM samples.
|
||||
pub fn generate_sine_wave(freq_hz: f32, sample_rate: u32, num_samples: usize) -> Vec<i16> {
|
||||
(0..num_samples)
|
||||
.map(|i| {
|
||||
let t = i as f32 / sample_rate as f32;
|
||||
(f32::sin(2.0 * std::f32::consts::PI * freq_hz * t) * 16000.0) as i16
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
// ─── Benchmarks ─────────────────────────────────────────────────────────────
|
||||
|
||||
/// Measure Opus encode+decode latency and throughput.
|
||||
///
|
||||
/// Generates 1000 frames of 440 Hz sine wave (48 kHz, 20 ms frames),
|
||||
/// encodes each, decodes each, and reports timing and compression ratio.
|
||||
pub fn bench_codec_roundtrip() -> CodecResult {
|
||||
let profile = QualityProfile::GOOD;
|
||||
let frame_samples = 960; // 20ms @ 48kHz
|
||||
let num_frames = 1000;
|
||||
|
||||
let pcm = generate_sine_wave(440.0, 48_000, frame_samples * num_frames);
|
||||
|
||||
let mut encoder = wzp_codec::create_encoder(profile);
|
||||
let mut decoder = wzp_codec::create_decoder(profile);
|
||||
|
||||
let max_enc = encoder.max_frame_bytes();
|
||||
let mut enc_buf = vec![0u8; max_enc];
|
||||
let mut dec_buf = vec![0i16; frame_samples];
|
||||
|
||||
let mut encoded_frames: Vec<Vec<u8>> = Vec::with_capacity(num_frames);
|
||||
let mut total_encoded_bytes: usize = 0;
|
||||
|
||||
// Encode
|
||||
let encode_start = Instant::now();
|
||||
for i in 0..num_frames {
|
||||
let start = i * frame_samples;
|
||||
let end = start + frame_samples;
|
||||
let n = encoder.encode(&pcm[start..end], &mut enc_buf).unwrap();
|
||||
encoded_frames.push(enc_buf[..n].to_vec());
|
||||
total_encoded_bytes += n;
|
||||
}
|
||||
let total_encode = encode_start.elapsed();
|
||||
|
||||
// Decode
|
||||
let decode_start = Instant::now();
|
||||
for frame in &encoded_frames {
|
||||
let _ = decoder.decode(frame, &mut dec_buf).unwrap();
|
||||
}
|
||||
let total_decode = decode_start.elapsed();
|
||||
|
||||
let total_pcm_bytes = num_frames * frame_samples * 2; // i16 = 2 bytes
|
||||
let compression_ratio = total_pcm_bytes as f64 / total_encoded_bytes as f64;
|
||||
let total_time = total_encode + total_decode;
|
||||
let frames_per_sec = num_frames as f64 / total_time.as_secs_f64();
|
||||
|
||||
CodecResult {
|
||||
frames: num_frames,
|
||||
total_encode,
|
||||
total_decode,
|
||||
avg_encode_us: total_encode.as_micros() as f64 / num_frames as f64,
|
||||
avg_decode_us: total_decode.as_micros() as f64 / num_frames as f64,
|
||||
frames_per_sec,
|
||||
compression_ratio,
|
||||
}
|
||||
}
|
||||
|
||||
/// Measure FEC encode/decode with simulated packet loss.
|
||||
///
|
||||
/// Encodes 100 blocks of 5 frames each, drops `loss_pct`% of packets
|
||||
/// randomly per block, and measures recovery rate.
|
||||
pub fn bench_fec_recovery(loss_pct: f32) -> FecResult {
|
||||
let profile = QualityProfile::GOOD; // 5 frames/block, 0.2 ratio
|
||||
let frames_per_block = profile.frames_per_block as usize;
|
||||
let num_blocks = 100;
|
||||
// Use a higher FEC ratio for the bench so recovery is possible at higher loss
|
||||
let fec_ratio = if loss_pct > 20.0 { 1.0 } else { 0.5 };
|
||||
|
||||
let start = Instant::now();
|
||||
|
||||
let mut blocks_recovered = 0usize;
|
||||
let mut total_source_bytes = 0usize;
|
||||
let mut total_repair_bytes = 0usize;
|
||||
|
||||
for block_idx in 0..num_blocks {
|
||||
let block_id = (block_idx % 256) as u8;
|
||||
|
||||
// Create fresh encoder and decoder for each block
|
||||
let mut fec_enc = RaptorQFecEncoder::new(frames_per_block, 256);
|
||||
let mut fec_dec = RaptorQFecDecoder::new(frames_per_block, 256);
|
||||
|
||||
// Generate source symbols (simulated encoded audio frames)
|
||||
let mut source_symbols: Vec<Vec<u8>> = Vec::new();
|
||||
for i in 0..frames_per_block {
|
||||
let val = ((block_idx * frames_per_block + i) & 0xFF) as u8;
|
||||
let sym = vec![val; 80];
|
||||
fec_enc.add_source_symbol(&sym).unwrap();
|
||||
source_symbols.push(sym);
|
||||
}
|
||||
|
||||
let repairs = fec_enc.generate_repair(fec_ratio).unwrap();
|
||||
|
||||
// Collect all symbols: source + repair
|
||||
struct Symbol {
|
||||
index: u8,
|
||||
is_repair: bool,
|
||||
data: Vec<u8>,
|
||||
}
|
||||
|
||||
let mut all_symbols: Vec<Symbol> = Vec::new();
|
||||
for (i, sym) in source_symbols.iter().enumerate() {
|
||||
// For add_symbol we need to provide the raw data; the decoder pads internally
|
||||
total_source_bytes += sym.len();
|
||||
all_symbols.push(Symbol {
|
||||
index: i as u8,
|
||||
is_repair: false,
|
||||
data: sym.clone(),
|
||||
});
|
||||
}
|
||||
for (idx, data) in &repairs {
|
||||
total_repair_bytes += data.len();
|
||||
all_symbols.push(Symbol {
|
||||
index: *idx,
|
||||
is_repair: true,
|
||||
data: data.clone(),
|
||||
});
|
||||
}
|
||||
|
||||
// Simulate loss: drop loss_pct% of symbols
|
||||
let drop_count =
|
||||
((all_symbols.len() as f32 * loss_pct / 100.0).round() as usize).min(all_symbols.len());
|
||||
|
||||
// Deterministic shuffle for reproducibility using a simple seed
|
||||
// We use a basic Fisher-Yates with a fixed-per-block seed
|
||||
let mut indices: Vec<usize> = (0..all_symbols.len()).collect();
|
||||
let mut seed = (block_idx as u64).wrapping_mul(6364136223846793005).wrapping_add(1);
|
||||
for i in (1..indices.len()).rev() {
|
||||
seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
|
||||
let j = (seed >> 33) as usize % (i + 1);
|
||||
indices.swap(i, j);
|
||||
}
|
||||
|
||||
// Keep all but `drop_count` symbols
|
||||
let keep_indices = &indices[drop_count..];
|
||||
|
||||
for &idx in keep_indices {
|
||||
let sym = &all_symbols[idx];
|
||||
let _ = fec_dec.add_symbol(block_id, sym.index, sym.is_repair, &sym.data);
|
||||
}
|
||||
|
||||
// Try to decode
|
||||
if let Ok(Some(_frames)) = fec_dec.try_decode(block_id) {
|
||||
blocks_recovered += 1;
|
||||
}
|
||||
}
|
||||
|
||||
let total_time = start.elapsed();
|
||||
|
||||
FecResult {
|
||||
blocks_attempted: num_blocks,
|
||||
blocks_recovered,
|
||||
recovery_rate_pct: blocks_recovered as f64 / num_blocks as f64 * 100.0,
|
||||
total_source_bytes,
|
||||
total_repair_bytes,
|
||||
overhead_bytes: total_repair_bytes,
|
||||
total_time,
|
||||
}
|
||||
}
|
||||
|
||||
/// Measure ChaCha20-Poly1305 encrypt+decrypt throughput.
|
||||
///
|
||||
/// Creates a crypto session pair and encrypts+decrypts 10000 packets
|
||||
/// of varying sizes (60, 120, 256 bytes).
|
||||
pub fn bench_encrypt_decrypt() -> CryptoResult {
|
||||
let key = [0x42u8; 32];
|
||||
let mut encryptor = ChaChaSession::new(key);
|
||||
let mut decryptor = ChaChaSession::new(key);
|
||||
|
||||
let sizes = [60usize, 120, 256];
|
||||
let packets_per_size = 10000;
|
||||
let total_packets = packets_per_size * sizes.len();
|
||||
|
||||
// Pre-generate payloads
|
||||
let payloads: Vec<Vec<u8>> = sizes
|
||||
.iter()
|
||||
.flat_map(|&sz| {
|
||||
(0..packets_per_size).map(move |i| {
|
||||
let val = (i & 0xFF) as u8;
|
||||
vec![val; sz]
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
let header = b"bench-header";
|
||||
let mut total_bytes: usize = 0;
|
||||
|
||||
let start = Instant::now();
|
||||
for payload in &payloads {
|
||||
let mut ciphertext = Vec::with_capacity(payload.len() + 16);
|
||||
encryptor.encrypt(header, payload, &mut ciphertext).unwrap();
|
||||
|
||||
let mut plaintext = Vec::with_capacity(payload.len());
|
||||
decryptor
|
||||
.decrypt(header, &ciphertext, &mut plaintext)
|
||||
.unwrap();
|
||||
|
||||
total_bytes += payload.len();
|
||||
}
|
||||
let total_time = start.elapsed();
|
||||
|
||||
let secs = total_time.as_secs_f64();
|
||||
|
||||
CryptoResult {
|
||||
packets: total_packets,
|
||||
total_time,
|
||||
packets_per_sec: total_packets as f64 / secs,
|
||||
megabytes_per_sec: (total_bytes as f64 / (1024.0 * 1024.0)) / secs,
|
||||
avg_latency_us: total_time.as_micros() as f64 / total_packets as f64,
|
||||
}
|
||||
}
|
||||
|
||||
/// End-to-end pipeline benchmark: PCM -> CallEncoder -> CallDecoder -> PCM.
|
||||
///
|
||||
/// Generates PCM, encodes through the full pipeline (codec + FEC),
|
||||
/// then feeds packets into the decoder side and measures throughput.
|
||||
pub fn bench_full_pipeline() -> PipelineResult {
|
||||
let config = CallConfig::default();
|
||||
let mut encoder = CallEncoder::new(&config);
|
||||
let mut decoder = CallDecoder::new(&config);
|
||||
|
||||
let frame_samples = 960; // 20ms @ 48kHz
|
||||
let num_frames = 50;
|
||||
|
||||
let pcm = generate_sine_wave(440.0, 48_000, frame_samples * num_frames);
|
||||
let pcm_bytes_in = num_frames * frame_samples * 2;
|
||||
|
||||
let mut all_packets = Vec::new();
|
||||
let mut wire_bytes_out: usize = 0;
|
||||
|
||||
// Encode pipeline
|
||||
let enc_start = Instant::now();
|
||||
for i in 0..num_frames {
|
||||
let start = i * frame_samples;
|
||||
let end = start + frame_samples;
|
||||
let packets = encoder.encode_frame(&pcm[start..end]).unwrap();
|
||||
for pkt in &packets {
|
||||
wire_bytes_out += pkt.payload.len();
|
||||
}
|
||||
all_packets.push(packets);
|
||||
}
|
||||
let total_encode_pipeline = enc_start.elapsed();
|
||||
|
||||
// Decode pipeline: ingest all packets, then try to decode
|
||||
let dec_start = Instant::now();
|
||||
let mut dec_pcm = vec![0i16; frame_samples];
|
||||
for packets in &all_packets {
|
||||
for pkt in packets {
|
||||
decoder.ingest(pkt.clone());
|
||||
}
|
||||
// Attempt to decode after each frame's packets are ingested
|
||||
let _ = decoder.decode_next(&mut dec_pcm);
|
||||
}
|
||||
// Drain any remaining frames
|
||||
while decoder.decode_next(&mut dec_pcm).is_some() {}
|
||||
let total_decode_pipeline = dec_start.elapsed();
|
||||
|
||||
let total_time = total_encode_pipeline + total_decode_pipeline;
|
||||
let overhead_ratio = wire_bytes_out as f64 / pcm_bytes_in as f64;
|
||||
|
||||
PipelineResult {
|
||||
frames: num_frames,
|
||||
total_encode_pipeline,
|
||||
total_decode_pipeline,
|
||||
avg_e2e_latency_us: total_time.as_micros() as f64 / num_frames as f64,
|
||||
pcm_bytes_in,
|
||||
wire_bytes_out,
|
||||
overhead_ratio,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn sine_wave_generates_correct_length() {
|
||||
let pcm = generate_sine_wave(440.0, 48_000, 960);
|
||||
assert_eq!(pcm.len(), 960);
|
||||
// Should have non-zero samples (it's a sine wave, not silence)
|
||||
assert!(pcm.iter().any(|&s| s != 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn codec_roundtrip_runs() {
|
||||
let result = bench_codec_roundtrip();
|
||||
assert_eq!(result.frames, 1000);
|
||||
assert!(result.frames_per_sec > 0.0);
|
||||
assert!(result.compression_ratio > 1.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fec_recovery_runs() {
|
||||
let result = bench_fec_recovery(10.0);
|
||||
assert_eq!(result.blocks_attempted, 100);
|
||||
assert!(result.blocks_recovered > 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn crypto_runs() {
|
||||
let result = bench_encrypt_decrypt();
|
||||
assert_eq!(result.packets, 30000);
|
||||
assert!(result.packets_per_sec > 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pipeline_runs() {
|
||||
let result = bench_full_pipeline();
|
||||
assert_eq!(result.frames, 200);
|
||||
assert!(result.wire_bytes_out > 0);
|
||||
}
|
||||
}
|
||||
152
crates/wzp-client/src/bench_cli.rs
Normal file
152
crates/wzp-client/src/bench_cli.rs
Normal file
@@ -0,0 +1,152 @@
|
||||
//! WarzonePhone benchmark CLI.
|
||||
//!
|
||||
//! Usage: wzp-bench [--codec] [--fec] [--crypto] [--pipeline] [--all]
|
||||
//! wzp-bench --fec --loss 30 (test FEC with 30% loss)
|
||||
|
||||
use wzp_client::bench;
|
||||
|
||||
fn print_header(title: &str) {
|
||||
println!();
|
||||
println!("┌─────────────────────────────────────────────────────┐");
|
||||
println!("│ {:<51} │", title);
|
||||
println!("├─────────────────────────────────────────────────────┤");
|
||||
}
|
||||
|
||||
fn print_row(label: &str, value: &str) {
|
||||
println!("│ {:<28} {:>20} │", label, value);
|
||||
}
|
||||
|
||||
fn print_footer() {
|
||||
println!("└─────────────────────────────────────────────────────┘");
|
||||
}
|
||||
|
||||
fn run_codec() {
|
||||
print_header("Codec Roundtrip (Opus 24kbps)");
|
||||
let r = bench::bench_codec_roundtrip();
|
||||
print_row("Frames", &format!("{}", r.frames));
|
||||
print_row("Encode total", &format!("{:.2} ms", r.total_encode.as_secs_f64() * 1000.0));
|
||||
print_row("Decode total", &format!("{:.2} ms", r.total_decode.as_secs_f64() * 1000.0));
|
||||
print_row("Avg encode", &format!("{:.1} us", r.avg_encode_us));
|
||||
print_row("Avg decode", &format!("{:.1} us", r.avg_decode_us));
|
||||
print_row("Throughput", &format!("{:.0} frames/sec", r.frames_per_sec));
|
||||
print_row("Compression ratio", &format!("{:.1}x", r.compression_ratio));
|
||||
print_footer();
|
||||
}
|
||||
|
||||
fn run_fec(loss_pct: f32) {
|
||||
print_header(&format!("FEC Recovery (loss={:.0}%)", loss_pct));
|
||||
let r = bench::bench_fec_recovery(loss_pct);
|
||||
print_row("Blocks attempted", &format!("{}", r.blocks_attempted));
|
||||
print_row("Blocks recovered", &format!("{}", r.blocks_recovered));
|
||||
print_row("Recovery rate", &format!("{:.1}%", r.recovery_rate_pct));
|
||||
print_row("Source bytes", &format!("{}", r.total_source_bytes));
|
||||
print_row("Repair (overhead) bytes", &format!("{}", r.overhead_bytes));
|
||||
print_row("Total time", &format!("{:.2} ms", r.total_time.as_secs_f64() * 1000.0));
|
||||
print_footer();
|
||||
}
|
||||
|
||||
fn run_crypto() {
|
||||
print_header("Crypto (ChaCha20-Poly1305)");
|
||||
let r = bench::bench_encrypt_decrypt();
|
||||
print_row("Packets", &format!("{}", r.packets));
|
||||
print_row("Total time", &format!("{:.2} ms", r.total_time.as_secs_f64() * 1000.0));
|
||||
print_row("Throughput", &format!("{:.0} pkt/sec", r.packets_per_sec));
|
||||
print_row("Bandwidth", &format!("{:.2} MB/sec", r.megabytes_per_sec));
|
||||
print_row("Avg latency", &format!("{:.2} us", r.avg_latency_us));
|
||||
print_footer();
|
||||
}
|
||||
|
||||
fn run_pipeline() {
|
||||
print_header("Full Pipeline (E2E)");
|
||||
let r = bench::bench_full_pipeline();
|
||||
print_row("Frames", &format!("{}", r.frames));
|
||||
print_row("Encode pipeline", &format!("{:.2} ms", r.total_encode_pipeline.as_secs_f64() * 1000.0));
|
||||
print_row("Decode pipeline", &format!("{:.2} ms", r.total_decode_pipeline.as_secs_f64() * 1000.0));
|
||||
print_row("Avg E2E latency", &format!("{:.1} us/frame", r.avg_e2e_latency_us));
|
||||
print_row("PCM in", &format!("{} bytes", r.pcm_bytes_in));
|
||||
print_row("Wire out", &format!("{} bytes", r.wire_bytes_out));
|
||||
print_row("Overhead ratio", &format!("{:.3}x", r.overhead_ratio));
|
||||
print_footer();
|
||||
}
|
||||
|
||||
fn print_usage() {
|
||||
println!("Usage: wzp-bench [OPTIONS]");
|
||||
println!();
|
||||
println!("Options:");
|
||||
println!(" --codec Run codec roundtrip benchmark");
|
||||
println!(" --fec Run FEC recovery benchmark");
|
||||
println!(" --crypto Run encryption benchmark");
|
||||
println!(" --pipeline Run full pipeline benchmark");
|
||||
println!(" --all Run all benchmarks (default)");
|
||||
println!(" --loss <N> FEC loss percentage (default: 20)");
|
||||
println!(" --help Show this help");
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
|
||||
if args.iter().any(|a| a == "--help" || a == "-h") {
|
||||
print_usage();
|
||||
return;
|
||||
}
|
||||
|
||||
let mut run_codec_flag = false;
|
||||
let mut run_fec_flag = false;
|
||||
let mut run_crypto_flag = false;
|
||||
let mut run_pipeline_flag = false;
|
||||
let mut loss_pct: f32 = 20.0;
|
||||
|
||||
let mut i = 0;
|
||||
while i < args.len() {
|
||||
match args[i].as_str() {
|
||||
"--codec" => run_codec_flag = true,
|
||||
"--fec" => run_fec_flag = true,
|
||||
"--crypto" => run_crypto_flag = true,
|
||||
"--pipeline" => run_pipeline_flag = true,
|
||||
"--all" => {
|
||||
run_codec_flag = true;
|
||||
run_fec_flag = true;
|
||||
run_crypto_flag = true;
|
||||
run_pipeline_flag = true;
|
||||
}
|
||||
"--loss" => {
|
||||
i += 1;
|
||||
if i < args.len() {
|
||||
loss_pct = args[i].parse().unwrap_or(20.0);
|
||||
}
|
||||
}
|
||||
other => {
|
||||
eprintln!("Unknown option: {}", other);
|
||||
print_usage();
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
|
||||
// Default: run all if no specific flag given
|
||||
if !run_codec_flag && !run_fec_flag && !run_crypto_flag && !run_pipeline_flag {
|
||||
run_codec_flag = true;
|
||||
run_fec_flag = true;
|
||||
run_crypto_flag = true;
|
||||
run_pipeline_flag = true;
|
||||
}
|
||||
|
||||
println!("=== WarzonePhone Protocol Benchmark ===");
|
||||
|
||||
if run_codec_flag {
|
||||
run_codec();
|
||||
}
|
||||
if run_fec_flag {
|
||||
run_fec(loss_pct);
|
||||
}
|
||||
if run_crypto_flag {
|
||||
run_crypto();
|
||||
}
|
||||
if run_pipeline_flag {
|
||||
run_pipeline();
|
||||
}
|
||||
|
||||
println!();
|
||||
println!("Done.");
|
||||
}
|
||||
@@ -160,8 +160,8 @@ pub struct CallDecoder {
|
||||
fec_dec: RaptorQFecDecoder,
|
||||
/// Jitter buffer.
|
||||
jitter: JitterBuffer,
|
||||
/// Quality controller.
|
||||
quality: AdaptiveQualityController,
|
||||
/// Quality controller (used when ingesting quality reports).
|
||||
pub quality: AdaptiveQualityController,
|
||||
/// Current profile.
|
||||
profile: QualityProfile,
|
||||
}
|
||||
@@ -208,8 +208,14 @@ impl CallDecoder {
|
||||
}
|
||||
}
|
||||
PlayoutResult::Missing { seq } => {
|
||||
debug!(seq, "packet loss, generating PLC");
|
||||
self.audio_dec.decode_lost(pcm).ok()
|
||||
// Only generate PLC if there are still packets buffered ahead.
|
||||
// Otherwise we've drained everything — return None to stop.
|
||||
if self.jitter.depth() > 0 {
|
||||
debug!(seq, "packet loss, generating PLC");
|
||||
self.audio_dec.decode_lost(pcm).ok()
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
PlayoutResult::NotReady => None,
|
||||
}
|
||||
|
||||
@@ -1,26 +1,34 @@
|
||||
//! WarzonePhone CLI test client.
|
||||
//!
|
||||
//! Usage: wzp-client <relay-addr>
|
||||
//! Usage: wzp-client [--live] [relay-addr]
|
||||
//!
|
||||
//! Connects to a relay and sends silence frames for testing.
|
||||
//! Without `--live`: sends silence frames for testing.
|
||||
//! With `--live`: captures microphone audio and plays received audio through speakers.
|
||||
|
||||
use std::net::SocketAddr;
|
||||
use std::sync::Arc;
|
||||
|
||||
use tracing::{error, info};
|
||||
|
||||
use wzp_client::call::{CallConfig, CallEncoder};
|
||||
use wzp_client::audio_io::{AudioCapture, AudioPlayback, FRAME_SAMPLES};
|
||||
use wzp_client::call::{CallConfig, CallDecoder, CallEncoder};
|
||||
use wzp_proto::MediaTransport;
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
tracing_subscriber::fmt().init();
|
||||
|
||||
let relay_addr: SocketAddr = std::env::args()
|
||||
.nth(1)
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let live = args.iter().any(|a| a == "--live");
|
||||
let relay_addr: SocketAddr = args
|
||||
.iter()
|
||||
.skip(1)
|
||||
.find(|a| *a != "--live")
|
||||
.cloned()
|
||||
.unwrap_or_else(|| "127.0.0.1:4433".to_string())
|
||||
.parse()?;
|
||||
|
||||
info!(%relay_addr, "WarzonePhone client connecting");
|
||||
info!(%relay_addr, live, "WarzonePhone client connecting");
|
||||
|
||||
let client_config = wzp_transport::client_config();
|
||||
let endpoint = wzp_transport::create_endpoint("0.0.0.0:0".parse()?, None)?;
|
||||
@@ -29,28 +37,136 @@ async fn main() -> anyhow::Result<()> {
|
||||
|
||||
info!("Connected to relay");
|
||||
|
||||
let transport = wzp_transport::QuinnTransport::new(connection);
|
||||
let transport = Arc::new(wzp_transport::QuinnTransport::new(connection));
|
||||
|
||||
if live {
|
||||
run_live(transport).await
|
||||
} else {
|
||||
run_silence(transport).await
|
||||
}
|
||||
}
|
||||
|
||||
/// Original test mode: send silence frames.
|
||||
async fn run_silence(transport: Arc<wzp_transport::QuinnTransport>) -> anyhow::Result<()> {
|
||||
let config = CallConfig::default();
|
||||
let mut encoder = CallEncoder::new(&config);
|
||||
|
||||
let frame_duration = tokio::time::Duration::from_millis(20);
|
||||
let pcm = vec![0i16; 960]; // 20ms @ 48kHz silence
|
||||
let pcm = vec![0i16; FRAME_SAMPLES]; // 20ms @ 48kHz silence
|
||||
|
||||
let mut total_source = 0u64;
|
||||
let mut total_repair = 0u64;
|
||||
let mut total_bytes = 0u64;
|
||||
|
||||
for i in 0..250u32 {
|
||||
let packets = encoder.encode_frame(&pcm)?;
|
||||
for pkt in &packets {
|
||||
if pkt.header.is_repair {
|
||||
total_repair += 1;
|
||||
} else {
|
||||
total_source += 1;
|
||||
}
|
||||
total_bytes += pkt.payload.len() as u64;
|
||||
if let Err(e) = transport.send_media(pkt).await {
|
||||
error!("send error: {e}");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if i % 50 == 0 {
|
||||
info!(frame = i, packets = packets.len(), "sent");
|
||||
if (i + 1) % 50 == 0 {
|
||||
info!(
|
||||
frame = i + 1,
|
||||
source = total_source,
|
||||
repair = total_repair,
|
||||
bytes = total_bytes,
|
||||
"progress"
|
||||
);
|
||||
}
|
||||
tokio::time::sleep(frame_duration).await;
|
||||
}
|
||||
|
||||
info!("Done, closing");
|
||||
info!(
|
||||
total_source,
|
||||
total_repair,
|
||||
total_bytes,
|
||||
"done — closing"
|
||||
);
|
||||
transport.close().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Live mode: capture from mic, encode, send; receive, decode, play.
|
||||
async fn run_live(transport: Arc<wzp_transport::QuinnTransport>) -> anyhow::Result<()> {
|
||||
let capture = AudioCapture::start()?;
|
||||
let playback = AudioPlayback::start()?;
|
||||
info!("Audio I/O started — press Ctrl+C to stop");
|
||||
|
||||
// --- Send task: mic -> encode -> transport ---
|
||||
// AudioCapture::read_frame() is blocking, so we run this on a dedicated
|
||||
// OS thread. We use the tokio Handle to call the async send_media.
|
||||
let send_transport = transport.clone();
|
||||
let rt_handle = tokio::runtime::Handle::current();
|
||||
let send_handle = std::thread::Builder::new()
|
||||
.name("wzp-send-loop".into())
|
||||
.spawn(move || {
|
||||
let config = CallConfig::default();
|
||||
let mut encoder = CallEncoder::new(&config);
|
||||
loop {
|
||||
let frame = match capture.read_frame() {
|
||||
Some(f) => f,
|
||||
None => break, // channel closed / stopped
|
||||
};
|
||||
let packets = match encoder.encode_frame(&frame) {
|
||||
Ok(p) => p,
|
||||
Err(e) => {
|
||||
error!("encode error: {e}");
|
||||
continue;
|
||||
}
|
||||
};
|
||||
for pkt in &packets {
|
||||
if let Err(e) = rt_handle.block_on(send_transport.send_media(pkt)) {
|
||||
error!("send error: {e}");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
})?;
|
||||
|
||||
// --- Recv task: transport -> decode -> speaker ---
|
||||
let recv_transport = transport.clone();
|
||||
let recv_handle = tokio::spawn(async move {
|
||||
let config = CallConfig::default();
|
||||
let mut decoder = CallDecoder::new(&config);
|
||||
let mut pcm_buf = vec![0i16; FRAME_SAMPLES];
|
||||
loop {
|
||||
match recv_transport.recv_media().await {
|
||||
Ok(Some(pkt)) => {
|
||||
decoder.ingest(pkt);
|
||||
while let Some(_n) = decoder.decode_next(&mut pcm_buf) {
|
||||
playback.write_frame(&pcm_buf);
|
||||
}
|
||||
}
|
||||
Ok(None) => {
|
||||
// No packet available right now, yield briefly.
|
||||
tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
|
||||
}
|
||||
Err(e) => {
|
||||
error!("recv error: {e}");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Wait for Ctrl+C
|
||||
tokio::signal::ctrl_c()
|
||||
.await
|
||||
.expect("failed to listen for Ctrl+C");
|
||||
info!("Shutting down...");
|
||||
|
||||
recv_handle.abort();
|
||||
// The send thread will exit once capture is dropped / stopped.
|
||||
drop(send_handle);
|
||||
transport.close().await?;
|
||||
info!("done");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
102
crates/wzp-client/src/handshake.rs
Normal file
102
crates/wzp-client/src/handshake.rs
Normal file
@@ -0,0 +1,102 @@
|
||||
//! Client-side cryptographic handshake.
|
||||
//!
|
||||
//! Performs the caller role of the WarzonePhone key exchange:
|
||||
//! send `CallOffer` → recv `CallAnswer` → derive shared `CryptoSession`.
|
||||
|
||||
use wzp_crypto::{CryptoSession, KeyExchange, WarzoneKeyExchange};
|
||||
use wzp_proto::{MediaTransport, QualityProfile, SignalMessage};
|
||||
|
||||
/// Perform the client (caller) side of the cryptographic handshake.
|
||||
///
|
||||
/// 1. Derive identity from `seed`
|
||||
/// 2. Generate ephemeral X25519 keypair
|
||||
/// 3. Sign `(ephemeral_pub || "call-offer")` with identity key
|
||||
/// 4. Send `CallOffer` with identity_pub, ephemeral_pub, signature
|
||||
/// 5. Receive `CallAnswer`, verify callee signature
|
||||
/// 6. Derive shared ChaCha20-Poly1305 session
|
||||
pub async fn perform_handshake(
|
||||
transport: &dyn MediaTransport,
|
||||
seed: &[u8; 32],
|
||||
) -> Result<Box<dyn CryptoSession>, anyhow::Error> {
|
||||
// 1. Create key exchange from identity seed
|
||||
let mut kx = WarzoneKeyExchange::from_identity_seed(seed);
|
||||
let identity_pub = kx.identity_public_key();
|
||||
|
||||
// 2. Generate ephemeral key
|
||||
let ephemeral_pub = kx.generate_ephemeral();
|
||||
|
||||
// 3. Sign (ephemeral_pub || "call-offer")
|
||||
let mut sign_data = Vec::with_capacity(32 + 10);
|
||||
sign_data.extend_from_slice(&ephemeral_pub);
|
||||
sign_data.extend_from_slice(b"call-offer");
|
||||
let signature = kx.sign(&sign_data);
|
||||
|
||||
// 4. Send CallOffer
|
||||
let offer = SignalMessage::CallOffer {
|
||||
identity_pub,
|
||||
ephemeral_pub,
|
||||
signature,
|
||||
supported_profiles: vec![
|
||||
QualityProfile::GOOD,
|
||||
QualityProfile::DEGRADED,
|
||||
QualityProfile::CATASTROPHIC,
|
||||
],
|
||||
};
|
||||
transport.send_signal(&offer).await?;
|
||||
|
||||
// 5. Wait for CallAnswer
|
||||
let answer = transport
|
||||
.recv_signal()
|
||||
.await?
|
||||
.ok_or_else(|| anyhow::anyhow!("connection closed before receiving CallAnswer"))?;
|
||||
|
||||
let (callee_identity_pub, callee_ephemeral_pub, callee_signature, _chosen_profile) = match answer
|
||||
{
|
||||
SignalMessage::CallAnswer {
|
||||
identity_pub,
|
||||
ephemeral_pub,
|
||||
signature,
|
||||
chosen_profile,
|
||||
} => (identity_pub, ephemeral_pub, signature, chosen_profile),
|
||||
other => {
|
||||
return Err(anyhow::anyhow!(
|
||||
"expected CallAnswer, got {:?}",
|
||||
std::mem::discriminant(&other)
|
||||
))
|
||||
}
|
||||
};
|
||||
|
||||
// 6. Verify callee's signature over (ephemeral_pub || "call-answer")
|
||||
let mut verify_data = Vec::with_capacity(32 + 11);
|
||||
verify_data.extend_from_slice(&callee_ephemeral_pub);
|
||||
verify_data.extend_from_slice(b"call-answer");
|
||||
if !WarzoneKeyExchange::verify(&callee_identity_pub, &verify_data, &callee_signature) {
|
||||
return Err(anyhow::anyhow!("callee signature verification failed"));
|
||||
}
|
||||
|
||||
// 7. Derive session
|
||||
let session = kx.derive_session(&callee_ephemeral_pub)?;
|
||||
|
||||
Ok(session)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// Integration test lives in tests/ — unit-level coverage relies on wzp-crypto tests.
|
||||
#[test]
|
||||
fn sign_data_format() {
|
||||
let kx = WarzoneKeyExchange::from_identity_seed(&[0xAA; 32]);
|
||||
let eph = [0x11u8; 32];
|
||||
let mut data = Vec::new();
|
||||
data.extend_from_slice(&eph);
|
||||
data.extend_from_slice(b"call-offer");
|
||||
let sig = kx.sign(&data);
|
||||
assert!(WarzoneKeyExchange::verify(
|
||||
&kx.identity_public_key(),
|
||||
&data,
|
||||
&sig,
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,11 @@
|
||||
//!
|
||||
//! Targets: Android (JNI), Windows desktop, macOS/Linux (testing)
|
||||
|
||||
pub mod audio_io;
|
||||
pub mod bench;
|
||||
pub mod call;
|
||||
pub mod handshake;
|
||||
|
||||
pub use audio_io::{AudioCapture, AudioPlayback};
|
||||
pub use call::{CallConfig, CallDecoder, CallEncoder};
|
||||
pub use handshake::perform_handshake;
|
||||
|
||||
176
crates/wzp-client/tests/handshake_integration.rs
Normal file
176
crates/wzp-client/tests/handshake_integration.rs
Normal file
@@ -0,0 +1,176 @@
|
||||
//! Integration test: full client-relay handshake with mock transport.
|
||||
//!
|
||||
//! Verifies that both sides derive the same session key by encrypting
|
||||
//! a message on one side and decrypting it on the other.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use async_trait::async_trait;
|
||||
use tokio::sync::mpsc;
|
||||
use tokio::sync::Mutex;
|
||||
|
||||
use wzp_proto::packet::MediaPacket;
|
||||
use wzp_proto::traits::{MediaTransport, PathQuality};
|
||||
use wzp_proto::{SignalMessage, TransportError};
|
||||
|
||||
/// A mock transport backed by two mpsc channels (one per direction).
|
||||
///
|
||||
/// `signal_tx` sends signals *to* the peer.
|
||||
/// `signal_rx` receives signals *from* the peer.
|
||||
struct MockTransport {
|
||||
signal_tx: mpsc::Sender<SignalMessage>,
|
||||
signal_rx: Mutex<mpsc::Receiver<SignalMessage>>,
|
||||
}
|
||||
|
||||
impl MockTransport {
|
||||
fn pair() -> (Arc<Self>, Arc<Self>) {
|
||||
let (tx_a, rx_a) = mpsc::channel(16);
|
||||
let (tx_b, rx_b) = mpsc::channel(16);
|
||||
|
||||
let a = Arc::new(Self {
|
||||
signal_tx: tx_b, // A sends to B's rx
|
||||
signal_rx: Mutex::new(rx_a),
|
||||
});
|
||||
let b = Arc::new(Self {
|
||||
signal_tx: tx_a, // B sends to A's rx
|
||||
signal_rx: Mutex::new(rx_b),
|
||||
});
|
||||
(a, b)
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl MediaTransport for MockTransport {
|
||||
async fn send_media(&self, _packet: &MediaPacket) -> Result<(), TransportError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn recv_media(&self) -> Result<Option<MediaPacket>, TransportError> {
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
async fn send_signal(&self, msg: &SignalMessage) -> Result<(), TransportError> {
|
||||
self.signal_tx
|
||||
.send(msg.clone())
|
||||
.await
|
||||
.map_err(|e| TransportError::Internal(format!("send failed: {e}")))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn recv_signal(&self) -> Result<Option<SignalMessage>, TransportError> {
|
||||
let mut rx = self.signal_rx.lock().await;
|
||||
Ok(rx.recv().await)
|
||||
}
|
||||
|
||||
fn path_quality(&self) -> PathQuality {
|
||||
PathQuality::default()
|
||||
}
|
||||
|
||||
async fn close(&self) -> Result<(), TransportError> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn full_handshake_both_sides_derive_same_session() {
|
||||
let (client_transport, relay_transport) = MockTransport::pair();
|
||||
|
||||
let client_seed = [0xAA_u8; 32];
|
||||
let relay_seed = [0xBB_u8; 32];
|
||||
|
||||
let client_transport_clone = Arc::clone(&client_transport);
|
||||
let relay_transport_clone = Arc::clone(&relay_transport);
|
||||
|
||||
// Run client and relay handshakes concurrently.
|
||||
let (client_result, relay_result) = tokio::join!(
|
||||
wzp_client::handshake::perform_handshake(client_transport_clone.as_ref(), &client_seed),
|
||||
wzp_relay::handshake::accept_handshake(relay_transport_clone.as_ref(), &relay_seed),
|
||||
);
|
||||
|
||||
let mut client_session = client_result.expect("client handshake should succeed");
|
||||
let (mut relay_session, chosen_profile) =
|
||||
relay_result.expect("relay handshake should succeed");
|
||||
|
||||
// Verify a profile was chosen.
|
||||
assert_eq!(chosen_profile, wzp_proto::QualityProfile::GOOD);
|
||||
|
||||
// Verify both sides can communicate: client encrypts, relay decrypts.
|
||||
let header = b"test-header";
|
||||
let plaintext = b"hello from client to relay";
|
||||
|
||||
let mut ciphertext = Vec::new();
|
||||
client_session
|
||||
.encrypt(header, plaintext, &mut ciphertext)
|
||||
.expect("client encrypt should succeed");
|
||||
|
||||
let mut decrypted = Vec::new();
|
||||
relay_session
|
||||
.decrypt(header, &ciphertext, &mut decrypted)
|
||||
.expect("relay decrypt should succeed");
|
||||
|
||||
assert_eq!(&decrypted[..], plaintext);
|
||||
|
||||
// Verify reverse direction: relay encrypts, client decrypts.
|
||||
let plaintext2 = b"hello from relay to client";
|
||||
let mut ciphertext2 = Vec::new();
|
||||
relay_session
|
||||
.encrypt(header, plaintext2, &mut ciphertext2)
|
||||
.expect("relay encrypt should succeed");
|
||||
|
||||
let mut decrypted2 = Vec::new();
|
||||
client_session
|
||||
.decrypt(header, &ciphertext2, &mut decrypted2)
|
||||
.expect("client decrypt should succeed");
|
||||
|
||||
assert_eq!(&decrypted2[..], plaintext2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn handshake_rejects_tampered_signature() {
|
||||
let (client_transport, relay_transport) = MockTransport::pair();
|
||||
|
||||
let _client_seed = [0xCC_u8; 32];
|
||||
let relay_seed = [0xDD_u8; 32];
|
||||
|
||||
// We'll manually tamper: run the relay side with a modified caller signature.
|
||||
// Create a custom client that sends a bad signature.
|
||||
let client_transport_clone = Arc::clone(&client_transport);
|
||||
|
||||
let bad_client = tokio::spawn(async move {
|
||||
use wzp_crypto::{KeyExchange, WarzoneKeyExchange};
|
||||
|
||||
let mut kx = WarzoneKeyExchange::from_identity_seed(&[0xCC_u8; 32]);
|
||||
let identity_pub = kx.identity_public_key();
|
||||
let ephemeral_pub = kx.generate_ephemeral();
|
||||
|
||||
// Create a BAD signature (sign wrong data)
|
||||
let bad_signature = kx.sign(b"wrong-data-intentionally");
|
||||
|
||||
let offer = SignalMessage::CallOffer {
|
||||
identity_pub,
|
||||
ephemeral_pub,
|
||||
signature: bad_signature,
|
||||
supported_profiles: vec![wzp_proto::QualityProfile::GOOD],
|
||||
};
|
||||
client_transport_clone
|
||||
.send_signal(&offer)
|
||||
.await
|
||||
.expect("send should work");
|
||||
});
|
||||
|
||||
let relay_result =
|
||||
wzp_relay::handshake::accept_handshake(relay_transport.as_ref(), &relay_seed).await;
|
||||
|
||||
bad_client.await.unwrap();
|
||||
|
||||
match relay_result {
|
||||
Err(e) => {
|
||||
let err_msg = e.to_string();
|
||||
assert!(
|
||||
err_msg.contains("signature verification failed"),
|
||||
"error should mention signature: {err_msg}"
|
||||
);
|
||||
}
|
||||
Ok(_) => panic!("relay should reject tampered signature"),
|
||||
}
|
||||
}
|
||||
@@ -13,8 +13,7 @@ tracing = { workspace = true }
|
||||
# Opus bindings
|
||||
audiopus = { workspace = true }
|
||||
|
||||
# TODO: Add codec2-sys when implementing Codec2 support
|
||||
# codec2-sys = "0.1"
|
||||
# rubato = "0.15" # resampling
|
||||
# Pure-Rust Codec2 implementation
|
||||
codec2 = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
|
||||
@@ -1,26 +1,38 @@
|
||||
//! Codec2 decoder — stub implementation.
|
||||
//! Codec2 decoder — real implementation via the pure-Rust `codec2` crate.
|
||||
//!
|
||||
//! Codec2 operates at 8 kHz mono. Resampling back to 48 kHz is handled
|
||||
//! externally (see `resample.rs` and `AdaptiveCodec`).
|
||||
//!
|
||||
//! This is a stub that returns an error on decode. When `codec2-sys`
|
||||
//! is linked, replace the body of `decode()` with actual FFI calls.
|
||||
|
||||
use codec2::{Codec2 as C2, Codec2Mode};
|
||||
use wzp_proto::{AudioDecoder, CodecError, CodecId, QualityProfile};
|
||||
|
||||
/// Stub Codec2 decoder implementing `AudioDecoder`.
|
||||
/// Maps our `CodecId` to the `codec2` crate's `Codec2Mode`.
|
||||
fn mode_for(codec: CodecId) -> Result<Codec2Mode, CodecError> {
|
||||
match codec {
|
||||
CodecId::Codec2_3200 => Ok(Codec2Mode::MODE_3200),
|
||||
CodecId::Codec2_1200 => Ok(Codec2Mode::MODE_1200),
|
||||
other => Err(CodecError::DecodeFailed(format!(
|
||||
"not a Codec2 variant: {other:?}"
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Codec2 decoder implementing `AudioDecoder`.
|
||||
///
|
||||
/// Currently returns `CodecError::DecodeFailed` for decode operations.
|
||||
/// PLC fills output with silence (zeros).
|
||||
/// Wraps the pure-Rust `codec2` crate. Output is 8 kHz mono i16 PCM;
|
||||
/// the `AdaptiveDecoder` handles 8 kHz -> 48 kHz upsampling.
|
||||
pub struct Codec2Decoder {
|
||||
inner: C2,
|
||||
codec_id: CodecId,
|
||||
frame_duration_ms: u8,
|
||||
}
|
||||
|
||||
impl Codec2Decoder {
|
||||
/// Create a new stub Codec2 decoder.
|
||||
/// Create a new Codec2 decoder for the given quality profile.
|
||||
pub fn new(profile: QualityProfile) -> Result<Self, CodecError> {
|
||||
let mode = mode_for(profile.codec)?;
|
||||
Ok(Self {
|
||||
inner: C2::new(mode),
|
||||
codec_id: profile.codec,
|
||||
frame_duration_ms: profile.frame_duration_ms,
|
||||
})
|
||||
@@ -28,21 +40,41 @@ impl Codec2Decoder {
|
||||
|
||||
/// Expected number of 8 kHz PCM output samples per frame.
|
||||
pub fn frame_samples(&self) -> usize {
|
||||
(8_000 * self.frame_duration_ms as usize) / 1000
|
||||
self.inner.samples_per_frame()
|
||||
}
|
||||
|
||||
/// Number of compressed bytes per frame.
|
||||
fn bytes_per_frame(&self) -> usize {
|
||||
(self.inner.bits_per_frame() + 7) / 8
|
||||
}
|
||||
}
|
||||
|
||||
impl AudioDecoder for Codec2Decoder {
|
||||
fn decode(&mut self, _encoded: &[u8], _pcm: &mut [i16]) -> Result<usize, CodecError> {
|
||||
Err(CodecError::DecodeFailed(
|
||||
"codec2-sys not yet linked".to_string(),
|
||||
))
|
||||
fn decode(&mut self, encoded: &[u8], pcm: &mut [i16]) -> Result<usize, CodecError> {
|
||||
let spf = self.inner.samples_per_frame();
|
||||
let bpf = self.bytes_per_frame();
|
||||
|
||||
if encoded.len() < bpf {
|
||||
return Err(CodecError::DecodeFailed(format!(
|
||||
"need {bpf} encoded bytes, got {}",
|
||||
encoded.len()
|
||||
)));
|
||||
}
|
||||
if pcm.len() < spf {
|
||||
return Err(CodecError::DecodeFailed(format!(
|
||||
"output buffer too small: need {spf} samples, got {}",
|
||||
pcm.len()
|
||||
)));
|
||||
}
|
||||
|
||||
self.inner.decode(&mut pcm[..spf], &encoded[..bpf]);
|
||||
Ok(spf)
|
||||
}
|
||||
|
||||
fn decode_lost(&mut self, pcm: &mut [i16]) -> Result<usize, CodecError> {
|
||||
let samples = self.frame_samples();
|
||||
// Codec2 has no built-in PLC. Fill with silence.
|
||||
let samples = self.inner.samples_per_frame();
|
||||
let n = samples.min(pcm.len());
|
||||
// Fill with silence as basic PLC
|
||||
pcm[..n].fill(0);
|
||||
Ok(n)
|
||||
}
|
||||
@@ -54,6 +86,11 @@ impl AudioDecoder for Codec2Decoder {
|
||||
fn set_profile(&mut self, profile: QualityProfile) -> Result<(), CodecError> {
|
||||
match profile.codec {
|
||||
CodecId::Codec2_3200 | CodecId::Codec2_1200 => {
|
||||
// Recreate the inner decoder if the mode changed.
|
||||
if profile.codec != self.codec_id {
|
||||
let mode = mode_for(profile.codec)?;
|
||||
self.inner = C2::new(mode);
|
||||
}
|
||||
self.codec_id = profile.codec;
|
||||
self.frame_duration_ms = profile.frame_duration_ms;
|
||||
Ok(())
|
||||
|
||||
@@ -1,26 +1,38 @@
|
||||
//! Codec2 encoder — stub implementation.
|
||||
//! Codec2 encoder — real implementation via the pure-Rust `codec2` crate.
|
||||
//!
|
||||
//! Codec2 operates at 8 kHz mono. Resampling from 48 kHz is handled
|
||||
//! externally (see `resample.rs` and `AdaptiveCodec`).
|
||||
//!
|
||||
//! This is a stub that returns an error on encode. When `codec2-sys`
|
||||
//! is linked, replace the body of `encode()` with actual FFI calls.
|
||||
|
||||
use codec2::{Codec2 as C2, Codec2Mode};
|
||||
use wzp_proto::{AudioEncoder, CodecError, CodecId, QualityProfile};
|
||||
|
||||
/// Stub Codec2 encoder implementing `AudioEncoder`.
|
||||
/// Maps our `CodecId` to the `codec2` crate's `Codec2Mode`.
|
||||
fn mode_for(codec: CodecId) -> Result<Codec2Mode, CodecError> {
|
||||
match codec {
|
||||
CodecId::Codec2_3200 => Ok(Codec2Mode::MODE_3200),
|
||||
CodecId::Codec2_1200 => Ok(Codec2Mode::MODE_1200),
|
||||
other => Err(CodecError::EncodeFailed(format!(
|
||||
"not a Codec2 variant: {other:?}"
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
/// Codec2 encoder implementing `AudioEncoder`.
|
||||
///
|
||||
/// Currently returns `CodecError::EncodeFailed` for all encode operations.
|
||||
/// The structure is ready for drop-in replacement once `codec2-sys` is available.
|
||||
/// Wraps the pure-Rust `codec2` crate. Input is 8 kHz mono i16 PCM;
|
||||
/// the `AdaptiveEncoder` handles 48 kHz -> 8 kHz resampling.
|
||||
pub struct Codec2Encoder {
|
||||
inner: C2,
|
||||
codec_id: CodecId,
|
||||
frame_duration_ms: u8,
|
||||
}
|
||||
|
||||
impl Codec2Encoder {
|
||||
/// Create a new stub Codec2 encoder.
|
||||
/// Create a new Codec2 encoder for the given quality profile.
|
||||
pub fn new(profile: QualityProfile) -> Result<Self, CodecError> {
|
||||
let mode = mode_for(profile.codec)?;
|
||||
Ok(Self {
|
||||
inner: C2::new(mode),
|
||||
codec_id: profile.codec,
|
||||
frame_duration_ms: profile.frame_duration_ms,
|
||||
})
|
||||
@@ -28,15 +40,35 @@ impl Codec2Encoder {
|
||||
|
||||
/// Expected number of 8 kHz PCM samples per frame.
|
||||
pub fn frame_samples(&self) -> usize {
|
||||
(8_000 * self.frame_duration_ms as usize) / 1000
|
||||
self.inner.samples_per_frame()
|
||||
}
|
||||
|
||||
/// Number of compressed bytes per frame.
|
||||
fn bytes_per_frame(&self) -> usize {
|
||||
(self.inner.bits_per_frame() + 7) / 8
|
||||
}
|
||||
}
|
||||
|
||||
impl AudioEncoder for Codec2Encoder {
|
||||
fn encode(&mut self, _pcm: &[i16], _out: &mut [u8]) -> Result<usize, CodecError> {
|
||||
Err(CodecError::EncodeFailed(
|
||||
"codec2-sys not yet linked".to_string(),
|
||||
))
|
||||
fn encode(&mut self, pcm: &[i16], out: &mut [u8]) -> Result<usize, CodecError> {
|
||||
let spf = self.inner.samples_per_frame();
|
||||
let bpf = self.bytes_per_frame();
|
||||
|
||||
if pcm.len() < spf {
|
||||
return Err(CodecError::EncodeFailed(format!(
|
||||
"need {spf} samples, got {}",
|
||||
pcm.len()
|
||||
)));
|
||||
}
|
||||
if out.len() < bpf {
|
||||
return Err(CodecError::EncodeFailed(format!(
|
||||
"output buffer too small: need {bpf} bytes, got {}",
|
||||
out.len()
|
||||
)));
|
||||
}
|
||||
|
||||
self.inner.encode(&mut out[..bpf], &pcm[..spf]);
|
||||
Ok(bpf)
|
||||
}
|
||||
|
||||
fn codec_id(&self) -> CodecId {
|
||||
@@ -46,6 +78,11 @@ impl AudioEncoder for Codec2Encoder {
|
||||
fn set_profile(&mut self, profile: QualityProfile) -> Result<(), CodecError> {
|
||||
match profile.codec {
|
||||
CodecId::Codec2_3200 | CodecId::Codec2_1200 => {
|
||||
// Recreate the inner encoder if the mode changed.
|
||||
if profile.codec != self.codec_id {
|
||||
let mode = mode_for(profile.codec)?;
|
||||
self.inner = C2::new(mode);
|
||||
}
|
||||
self.codec_id = profile.codec;
|
||||
self.frame_duration_ms = profile.frame_duration_ms;
|
||||
Ok(())
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
//!
|
||||
//! Provides audio encoding/decoding with adaptive codec switching:
|
||||
//! - Opus (24kbps / 16kbps / 6kbps) for normal to degraded conditions
|
||||
//! - Codec2 (3200bps / 1200bps) via C bindings for catastrophic conditions
|
||||
//! - Codec2 (3200bps / 1200bps) via the pure-Rust `codec2` crate for catastrophic conditions
|
||||
//!
|
||||
//! ## Usage
|
||||
//!
|
||||
@@ -40,3 +40,184 @@ pub fn create_decoder(profile: QualityProfile) -> Box<dyn AudioDecoder> {
|
||||
.expect("failed to create adaptive decoder"),
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod codec2_tests {
|
||||
use super::*;
|
||||
use crate::codec2_dec::Codec2Decoder;
|
||||
use crate::codec2_enc::Codec2Encoder;
|
||||
|
||||
fn c2_3200_profile() -> QualityProfile {
|
||||
QualityProfile {
|
||||
codec: CodecId::Codec2_3200,
|
||||
fec_ratio: 0.5,
|
||||
frame_duration_ms: 20,
|
||||
frames_per_block: 5,
|
||||
}
|
||||
}
|
||||
|
||||
fn c2_1200_profile() -> QualityProfile {
|
||||
QualityProfile::CATASTROPHIC
|
||||
}
|
||||
|
||||
// ── Frame size tests ────────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn codec2_3200_frame_sizes() {
|
||||
let enc = Codec2Encoder::new(c2_3200_profile()).unwrap();
|
||||
// 3200bps: 160 samples/frame @ 8kHz (20ms), 8 bytes output
|
||||
assert_eq!(enc.frame_samples(), 160);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn codec2_1200_frame_sizes() {
|
||||
let enc = Codec2Encoder::new(c2_1200_profile()).unwrap();
|
||||
// 1200bps: 320 samples/frame @ 8kHz (40ms), 6 bytes output
|
||||
assert_eq!(enc.frame_samples(), 320);
|
||||
}
|
||||
|
||||
// ── Encode/Decode roundtrip tests ───────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn codec2_3200_encode_decode_roundtrip() {
|
||||
let mut enc = Codec2Encoder::new(c2_3200_profile()).unwrap();
|
||||
let mut dec = Codec2Decoder::new(c2_3200_profile()).unwrap();
|
||||
|
||||
// 160 samples of silence at 8kHz
|
||||
let pcm_in = vec![0i16; 160];
|
||||
let mut encoded = vec![0u8; 16];
|
||||
let enc_bytes = enc.encode(&pcm_in, &mut encoded).unwrap();
|
||||
assert_eq!(enc_bytes, 8, "3200bps should produce 8 bytes per frame");
|
||||
|
||||
let mut pcm_out = vec![0i16; 160];
|
||||
let dec_samples = dec.decode(&encoded[..enc_bytes], &mut pcm_out).unwrap();
|
||||
assert_eq!(dec_samples, 160, "3200bps should decode to 160 samples");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn codec2_1200_encode_decode_roundtrip() {
|
||||
let mut enc = Codec2Encoder::new(c2_1200_profile()).unwrap();
|
||||
let mut dec = Codec2Decoder::new(c2_1200_profile()).unwrap();
|
||||
|
||||
// 320 samples of silence at 8kHz
|
||||
let pcm_in = vec![0i16; 320];
|
||||
let mut encoded = vec![0u8; 16];
|
||||
let enc_bytes = enc.encode(&pcm_in, &mut encoded).unwrap();
|
||||
assert_eq!(enc_bytes, 6, "1200bps should produce 6 bytes per frame");
|
||||
|
||||
let mut pcm_out = vec![0i16; 320];
|
||||
let dec_samples = dec.decode(&encoded[..enc_bytes], &mut pcm_out).unwrap();
|
||||
assert_eq!(dec_samples, 320, "1200bps should decode to 320 samples");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn codec2_3200_encode_produces_bytes() {
|
||||
let mut enc = Codec2Encoder::new(c2_3200_profile()).unwrap();
|
||||
|
||||
// Feed a non-silent signal to ensure encoding produces non-trivial output.
|
||||
let pcm_in: Vec<i16> = (0..160).map(|i| (i * 100) as i16).collect();
|
||||
let mut encoded = vec![0u8; 16];
|
||||
let n = enc.encode(&pcm_in, &mut encoded).unwrap();
|
||||
assert_eq!(n, 8);
|
||||
// At least some non-zero bytes in the output.
|
||||
assert!(encoded[..n].iter().any(|&b| b != 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn codec2_1200_encode_produces_bytes() {
|
||||
let mut enc = Codec2Encoder::new(c2_1200_profile()).unwrap();
|
||||
|
||||
let pcm_in: Vec<i16> = (0..320).map(|i| (i * 50) as i16).collect();
|
||||
let mut encoded = vec![0u8; 16];
|
||||
let n = enc.encode(&pcm_in, &mut encoded).unwrap();
|
||||
assert_eq!(n, 6);
|
||||
assert!(encoded[..n].iter().any(|&b| b != 0));
|
||||
}
|
||||
|
||||
// ── Error handling tests ────────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn codec2_encode_rejects_short_input() {
|
||||
let mut enc = Codec2Encoder::new(c2_3200_profile()).unwrap();
|
||||
let pcm_in = vec![0i16; 10]; // too few samples
|
||||
let mut out = vec![0u8; 16];
|
||||
assert!(enc.encode(&pcm_in, &mut out).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn codec2_decode_rejects_short_input() {
|
||||
let mut dec = Codec2Decoder::new(c2_3200_profile()).unwrap();
|
||||
let encoded = vec![0u8; 2]; // too few bytes
|
||||
let mut pcm = vec![0i16; 160];
|
||||
assert!(dec.decode(&encoded, &mut pcm).is_err());
|
||||
}
|
||||
|
||||
// ── Adaptive switching: Opus → Codec2 → Opus roundtrip ─────────────
|
||||
|
||||
#[test]
|
||||
fn adaptive_opus_to_codec2_to_opus_roundtrip() {
|
||||
let mut enc = AdaptiveEncoder::new(QualityProfile::GOOD).unwrap();
|
||||
let mut dec = AdaptiveDecoder::new(QualityProfile::GOOD).unwrap();
|
||||
|
||||
// Step 1: Encode/decode with Opus (20ms @ 48kHz = 960 samples).
|
||||
let pcm_48k = vec![0i16; 960];
|
||||
let mut encoded = vec![0u8; 512];
|
||||
let n = enc.encode(&pcm_48k, &mut encoded).unwrap();
|
||||
assert!(n > 0);
|
||||
let mut pcm_out = vec![0i16; 960];
|
||||
let samples = dec.decode(&encoded[..n], &mut pcm_out).unwrap();
|
||||
assert_eq!(samples, 960);
|
||||
|
||||
// Step 2: Switch to Codec2 1200.
|
||||
enc.set_profile(QualityProfile::CATASTROPHIC).unwrap();
|
||||
dec.set_profile(QualityProfile::CATASTROPHIC).unwrap();
|
||||
assert_eq!(enc.codec_id(), CodecId::Codec2_1200);
|
||||
|
||||
// Codec2 1200 @ 40ms needs 1920 samples at 48kHz (resampled internally to 320 @ 8kHz).
|
||||
let pcm_48k_c2 = vec![0i16; 1920];
|
||||
let mut encoded_c2 = vec![0u8; 16];
|
||||
let n_c2 = enc.encode(&pcm_48k_c2, &mut encoded_c2).unwrap();
|
||||
assert_eq!(n_c2, 6, "Codec2 1200 should produce 6 bytes");
|
||||
|
||||
let mut pcm_out_c2 = vec![0i16; 1920];
|
||||
let samples_c2 = dec.decode(&encoded_c2[..n_c2], &mut pcm_out_c2).unwrap();
|
||||
assert_eq!(samples_c2, 1920, "should get 1920 samples at 48kHz after upsample");
|
||||
|
||||
// Step 3: Switch back to Opus.
|
||||
enc.set_profile(QualityProfile::GOOD).unwrap();
|
||||
dec.set_profile(QualityProfile::GOOD).unwrap();
|
||||
assert_eq!(enc.codec_id(), CodecId::Opus24k);
|
||||
|
||||
let n_opus = enc.encode(&pcm_48k, &mut encoded).unwrap();
|
||||
assert!(n_opus > 0);
|
||||
let samples_opus = dec.decode(&encoded[..n_opus], &mut pcm_out).unwrap();
|
||||
assert_eq!(samples_opus, 960);
|
||||
}
|
||||
|
||||
// ── PLC (decode_lost) test ──────────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn codec2_decode_lost_produces_silence() {
|
||||
let mut dec = Codec2Decoder::new(c2_3200_profile()).unwrap();
|
||||
let mut pcm = vec![1i16; 160];
|
||||
let n = dec.decode_lost(&mut pcm).unwrap();
|
||||
assert_eq!(n, 160);
|
||||
assert!(pcm.iter().all(|&s| s == 0));
|
||||
}
|
||||
|
||||
// ── Mode switching within Codec2 ────────────────────────────────────
|
||||
|
||||
#[test]
|
||||
fn codec2_encoder_switches_3200_to_1200() {
|
||||
let mut enc = Codec2Encoder::new(c2_3200_profile()).unwrap();
|
||||
assert_eq!(enc.frame_samples(), 160);
|
||||
|
||||
enc.set_profile(c2_1200_profile()).unwrap();
|
||||
assert_eq!(enc.frame_samples(), 320);
|
||||
|
||||
let pcm_in = vec![0i16; 320];
|
||||
let mut out = vec![0u8; 16];
|
||||
let n = enc.encode(&pcm_in, &mut out).unwrap();
|
||||
assert_eq!(n, 6);
|
||||
}
|
||||
}
|
||||
|
||||
120
crates/wzp-relay/src/handshake.rs
Normal file
120
crates/wzp-relay/src/handshake.rs
Normal file
@@ -0,0 +1,120 @@
|
||||
//! Relay-side (callee) cryptographic handshake.
|
||||
//!
|
||||
//! Performs the callee role of the WarzonePhone key exchange:
|
||||
//! recv `CallOffer` → verify → generate ephemeral → derive session → send `CallAnswer`.
|
||||
|
||||
use wzp_crypto::{CryptoSession, KeyExchange, WarzoneKeyExchange};
|
||||
use wzp_proto::{MediaTransport, QualityProfile, SignalMessage};
|
||||
|
||||
/// Accept the relay (callee) side of the cryptographic handshake.
|
||||
///
|
||||
/// 1. Receive `CallOffer` from client
|
||||
/// 2. Verify caller's signature over `(ephemeral_pub || "call-offer")`
|
||||
/// 3. Generate our own ephemeral X25519 keypair
|
||||
/// 4. Sign `(ephemeral_pub || "call-answer")` with our identity key
|
||||
/// 5. Derive shared ChaCha20-Poly1305 session
|
||||
/// 6. Send `CallAnswer` back
|
||||
///
|
||||
/// Returns the derived `CryptoSession` and the chosen `QualityProfile`.
|
||||
pub async fn accept_handshake(
|
||||
transport: &dyn MediaTransport,
|
||||
seed: &[u8; 32],
|
||||
) -> Result<(Box<dyn CryptoSession>, QualityProfile), anyhow::Error> {
|
||||
// 1. Receive CallOffer
|
||||
let offer = transport
|
||||
.recv_signal()
|
||||
.await?
|
||||
.ok_or_else(|| anyhow::anyhow!("connection closed before receiving CallOffer"))?;
|
||||
|
||||
let (caller_identity_pub, caller_ephemeral_pub, caller_signature, supported_profiles) =
|
||||
match offer {
|
||||
SignalMessage::CallOffer {
|
||||
identity_pub,
|
||||
ephemeral_pub,
|
||||
signature,
|
||||
supported_profiles,
|
||||
} => (identity_pub, ephemeral_pub, signature, supported_profiles),
|
||||
other => {
|
||||
return Err(anyhow::anyhow!(
|
||||
"expected CallOffer, got {:?}",
|
||||
std::mem::discriminant(&other)
|
||||
))
|
||||
}
|
||||
};
|
||||
|
||||
// 2. Verify caller's signature over (ephemeral_pub || "call-offer")
|
||||
let mut verify_data = Vec::with_capacity(32 + 10);
|
||||
verify_data.extend_from_slice(&caller_ephemeral_pub);
|
||||
verify_data.extend_from_slice(b"call-offer");
|
||||
if !WarzoneKeyExchange::verify(&caller_identity_pub, &verify_data, &caller_signature) {
|
||||
return Err(anyhow::anyhow!("caller signature verification failed"));
|
||||
}
|
||||
|
||||
// 3. Create our key exchange and generate ephemeral
|
||||
let mut kx = WarzoneKeyExchange::from_identity_seed(seed);
|
||||
let identity_pub = kx.identity_public_key();
|
||||
let ephemeral_pub = kx.generate_ephemeral();
|
||||
|
||||
// 4. Sign (ephemeral_pub || "call-answer")
|
||||
let mut sign_data = Vec::with_capacity(32 + 11);
|
||||
sign_data.extend_from_slice(&ephemeral_pub);
|
||||
sign_data.extend_from_slice(b"call-answer");
|
||||
let signature = kx.sign(&sign_data);
|
||||
|
||||
// 5. Derive session from caller's ephemeral public key
|
||||
let session = kx.derive_session(&caller_ephemeral_pub)?;
|
||||
|
||||
// Choose the best supported profile (prefer GOOD > DEGRADED > CATASTROPHIC)
|
||||
let chosen_profile = choose_profile(&supported_profiles);
|
||||
|
||||
// 6. Send CallAnswer
|
||||
let answer = SignalMessage::CallAnswer {
|
||||
identity_pub,
|
||||
ephemeral_pub,
|
||||
signature,
|
||||
chosen_profile,
|
||||
};
|
||||
transport.send_signal(&answer).await?;
|
||||
|
||||
Ok((session, chosen_profile))
|
||||
}
|
||||
|
||||
/// Select the best quality profile from those the caller supports.
|
||||
fn choose_profile(supported: &[QualityProfile]) -> QualityProfile {
|
||||
// Prefer higher-quality profiles. Use GOOD as default if supported list is empty.
|
||||
if supported.is_empty() {
|
||||
return QualityProfile::GOOD;
|
||||
}
|
||||
// Pick the profile with the highest bitrate.
|
||||
supported
|
||||
.iter()
|
||||
.max_by(|a, b| {
|
||||
a.total_bitrate_kbps()
|
||||
.partial_cmp(&b.total_bitrate_kbps())
|
||||
.unwrap_or(std::cmp::Ordering::Equal)
|
||||
})
|
||||
.copied()
|
||||
.unwrap_or(QualityProfile::GOOD)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn choose_profile_picks_highest_bitrate() {
|
||||
let profiles = vec![
|
||||
QualityProfile::CATASTROPHIC,
|
||||
QualityProfile::GOOD,
|
||||
QualityProfile::DEGRADED,
|
||||
];
|
||||
let chosen = choose_profile(&profiles);
|
||||
assert_eq!(chosen, QualityProfile::GOOD);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn choose_profile_empty_defaults_to_good() {
|
||||
let chosen = choose_profile(&[]);
|
||||
assert_eq!(chosen, QualityProfile::GOOD);
|
||||
}
|
||||
}
|
||||
@@ -8,9 +8,11 @@
|
||||
//! quality transitions.
|
||||
|
||||
pub mod config;
|
||||
pub mod handshake;
|
||||
pub mod pipeline;
|
||||
pub mod session_mgr;
|
||||
|
||||
pub use config::RelayConfig;
|
||||
pub use handshake::accept_handshake;
|
||||
pub use pipeline::{PipelineConfig, PipelineStats, RelayPipeline};
|
||||
pub use session_mgr::{RelaySession, SessionId, SessionManager};
|
||||
|
||||
@@ -1,28 +1,197 @@
|
||||
//! WarzonePhone relay daemon entry point.
|
||||
//!
|
||||
//! Accepts client QUIC connections and optionally forwards media to a remote
|
||||
//! relay. Each client connection spawns two tasks for bidirectional forwarding
|
||||
//! through the relay pipeline (FEC decode -> jitter -> FEC encode).
|
||||
|
||||
use std::net::SocketAddr;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use tokio::sync::Mutex;
|
||||
use tracing::{error, info};
|
||||
use tracing::{error, info, warn};
|
||||
|
||||
use wzp_proto::MediaTransport;
|
||||
use wzp_relay::config::RelayConfig;
|
||||
use wzp_relay::pipeline::{PipelineConfig, RelayPipeline};
|
||||
use wzp_relay::session_mgr::SessionManager;
|
||||
|
||||
/// Parse CLI arguments using std::env::args().
|
||||
///
|
||||
/// Usage: wzp-relay [--listen <addr>] [--remote <addr>]
|
||||
fn parse_args() -> RelayConfig {
|
||||
let mut config = RelayConfig::default();
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let mut i = 1;
|
||||
while i < args.len() {
|
||||
match args[i].as_str() {
|
||||
"--listen" => {
|
||||
i += 1;
|
||||
if i < args.len() {
|
||||
config.listen_addr = args[i]
|
||||
.parse::<SocketAddr>()
|
||||
.expect("invalid --listen address");
|
||||
} else {
|
||||
eprintln!("--listen requires an address argument");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
"--remote" => {
|
||||
i += 1;
|
||||
if i < args.len() {
|
||||
config.remote_relay = Some(
|
||||
args[i]
|
||||
.parse::<SocketAddr>()
|
||||
.expect("invalid --remote address"),
|
||||
);
|
||||
} else {
|
||||
eprintln!("--remote requires an address argument");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
"--help" | "-h" => {
|
||||
eprintln!("Usage: wzp-relay [--listen <addr>] [--remote <addr>]");
|
||||
eprintln!();
|
||||
eprintln!("Options:");
|
||||
eprintln!(" --listen <addr> Listen address (default: 0.0.0.0:4433)");
|
||||
eprintln!(" --remote <addr> Remote relay address for forwarding");
|
||||
std::process::exit(0);
|
||||
}
|
||||
other => {
|
||||
eprintln!("unknown argument: {other}");
|
||||
eprintln!("Usage: wzp-relay [--listen <addr>] [--remote <addr>]");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
i += 1;
|
||||
}
|
||||
config
|
||||
}
|
||||
|
||||
/// Shared packet counters for periodic logging.
|
||||
struct RelayStats {
|
||||
upstream_packets: AtomicU64,
|
||||
downstream_packets: AtomicU64,
|
||||
}
|
||||
|
||||
/// Run the upstream forwarding task: client -> pipeline -> remote.
|
||||
async fn run_upstream(
|
||||
client_transport: Arc<wzp_transport::QuinnTransport>,
|
||||
remote_transport: Arc<wzp_transport::QuinnTransport>,
|
||||
pipeline: Arc<Mutex<RelayPipeline>>,
|
||||
stats: Arc<RelayStats>,
|
||||
) {
|
||||
loop {
|
||||
let packet = match client_transport.recv_media().await {
|
||||
Ok(Some(pkt)) => pkt,
|
||||
Ok(None) => {
|
||||
info!("client connection closed (upstream)");
|
||||
break;
|
||||
}
|
||||
Err(e) => {
|
||||
error!("upstream recv error: {e}");
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
// Process through pipeline
|
||||
let outbound = {
|
||||
let mut pipe = pipeline.lock().await;
|
||||
let decoded = pipe.ingest(packet);
|
||||
let mut out = Vec::new();
|
||||
for pkt in decoded {
|
||||
out.extend(pipe.prepare_outbound(pkt));
|
||||
}
|
||||
out
|
||||
};
|
||||
|
||||
// Forward to remote
|
||||
for pkt in &outbound {
|
||||
if let Err(e) = remote_transport.send_media(pkt).await {
|
||||
error!("upstream send error: {e}");
|
||||
return;
|
||||
}
|
||||
}
|
||||
stats
|
||||
.upstream_packets
|
||||
.fetch_add(outbound.len() as u64, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
/// Run the downstream forwarding task: remote -> pipeline -> client.
|
||||
async fn run_downstream(
|
||||
client_transport: Arc<wzp_transport::QuinnTransport>,
|
||||
remote_transport: Arc<wzp_transport::QuinnTransport>,
|
||||
pipeline: Arc<Mutex<RelayPipeline>>,
|
||||
stats: Arc<RelayStats>,
|
||||
) {
|
||||
loop {
|
||||
let packet = match remote_transport.recv_media().await {
|
||||
Ok(Some(pkt)) => pkt,
|
||||
Ok(None) => {
|
||||
info!("remote connection closed (downstream)");
|
||||
break;
|
||||
}
|
||||
Err(e) => {
|
||||
error!("downstream recv error: {e}");
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
// Process through pipeline
|
||||
let outbound = {
|
||||
let mut pipe = pipeline.lock().await;
|
||||
let decoded = pipe.ingest(packet);
|
||||
let mut out = Vec::new();
|
||||
for pkt in decoded {
|
||||
out.extend(pipe.prepare_outbound(pkt));
|
||||
}
|
||||
out
|
||||
};
|
||||
|
||||
// Forward to client
|
||||
for pkt in &outbound {
|
||||
if let Err(e) = client_transport.send_media(pkt).await {
|
||||
error!("downstream send error: {e}");
|
||||
return;
|
||||
}
|
||||
}
|
||||
stats
|
||||
.downstream_packets
|
||||
.fetch_add(outbound.len() as u64, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
let config = RelayConfig::default();
|
||||
let config = parse_args();
|
||||
|
||||
tracing_subscriber::fmt().init();
|
||||
|
||||
info!(addr = %config.listen_addr, "WarzonePhone relay starting");
|
||||
if let Some(remote) = config.remote_relay {
|
||||
info!(%remote, "will connect to remote relay");
|
||||
}
|
||||
|
||||
let (server_config, _cert_der) = wzp_transport::server_config();
|
||||
let endpoint =
|
||||
wzp_transport::create_endpoint(config.listen_addr, Some(server_config))?;
|
||||
let endpoint = wzp_transport::create_endpoint(config.listen_addr, Some(server_config))?;
|
||||
|
||||
let sessions = Arc::new(Mutex::new(SessionManager::new(config.max_sessions)));
|
||||
|
||||
// If a remote relay is configured, connect to it on startup
|
||||
let remote_transport: Option<Arc<wzp_transport::QuinnTransport>> =
|
||||
if let Some(remote_addr) = config.remote_relay {
|
||||
info!(%remote_addr, "connecting to remote relay");
|
||||
let client_cfg = wzp_transport::client_config();
|
||||
let remote_conn =
|
||||
wzp_transport::connect(&endpoint, remote_addr, "localhost", client_cfg).await?;
|
||||
info!(%remote_addr, "connected to remote relay");
|
||||
Some(Arc::new(wzp_transport::QuinnTransport::new(remote_conn)))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
info!("Listening for connections...");
|
||||
|
||||
loop {
|
||||
@@ -34,30 +203,113 @@ async fn main() -> anyhow::Result<()> {
|
||||
}
|
||||
};
|
||||
|
||||
let _sessions = sessions.clone();
|
||||
let sessions = sessions.clone();
|
||||
let remote_transport = remote_transport.clone();
|
||||
|
||||
tokio::spawn(async move {
|
||||
let remote = connection.remote_address();
|
||||
info!(%remote, "new connection");
|
||||
let remote_addr = connection.remote_address();
|
||||
info!(%remote_addr, "new client connection");
|
||||
|
||||
let transport = wzp_transport::QuinnTransport::new(connection);
|
||||
let client_transport = Arc::new(wzp_transport::QuinnTransport::new(connection));
|
||||
|
||||
loop {
|
||||
match transport.recv_media().await {
|
||||
Ok(Some(packet)) => {
|
||||
tracing::trace!(
|
||||
seq = packet.header.seq,
|
||||
block = packet.header.fec_block,
|
||||
"received media packet"
|
||||
);
|
||||
match remote_transport {
|
||||
Some(remote_tx) => {
|
||||
// Create pipelines for both directions
|
||||
let upstream_pipeline =
|
||||
Arc::new(Mutex::new(RelayPipeline::new(PipelineConfig::default())));
|
||||
let downstream_pipeline =
|
||||
Arc::new(Mutex::new(RelayPipeline::new(PipelineConfig::default())));
|
||||
|
||||
// Register session
|
||||
{
|
||||
let mut mgr = sessions.lock().await;
|
||||
let session_id = {
|
||||
let mut id = [0u8; 16];
|
||||
let addr_bytes = remote_addr.to_string();
|
||||
let bytes = addr_bytes.as_bytes();
|
||||
let len = bytes.len().min(16);
|
||||
id[..len].copy_from_slice(&bytes[..len]);
|
||||
id
|
||||
};
|
||||
mgr.create_session(session_id, PipelineConfig::default());
|
||||
}
|
||||
Ok(None) => {
|
||||
info!(%remote, "connection closed");
|
||||
break;
|
||||
|
||||
let stats = Arc::new(RelayStats {
|
||||
upstream_packets: AtomicU64::new(0),
|
||||
downstream_packets: AtomicU64::new(0),
|
||||
});
|
||||
|
||||
// Spawn periodic stats logger
|
||||
let stats_log = stats.clone();
|
||||
let log_remote = remote_addr;
|
||||
let stats_handle = tokio::spawn(async move {
|
||||
let mut interval = tokio::time::interval(Duration::from_secs(5));
|
||||
loop {
|
||||
interval.tick().await;
|
||||
let up = stats_log.upstream_packets.load(Ordering::Relaxed);
|
||||
let down = stats_log.downstream_packets.load(Ordering::Relaxed);
|
||||
info!(
|
||||
client = %log_remote,
|
||||
upstream = up,
|
||||
downstream = down,
|
||||
"relay stats"
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
// Spawn upstream and downstream tasks
|
||||
let up_handle = tokio::spawn(run_upstream(
|
||||
client_transport.clone(),
|
||||
remote_tx.clone(),
|
||||
upstream_pipeline,
|
||||
stats.clone(),
|
||||
));
|
||||
|
||||
let down_handle = tokio::spawn(run_downstream(
|
||||
client_transport.clone(),
|
||||
remote_tx,
|
||||
downstream_pipeline,
|
||||
stats,
|
||||
));
|
||||
|
||||
// Wait for either direction to finish, then clean up
|
||||
tokio::select! {
|
||||
_ = up_handle => {
|
||||
info!(%remote_addr, "upstream task ended");
|
||||
}
|
||||
_ = down_handle => {
|
||||
info!(%remote_addr, "downstream task ended");
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
error!(%remote, "recv error: {e}");
|
||||
break;
|
||||
|
||||
// Abort the stats logger and close transport
|
||||
stats_handle.abort();
|
||||
if let Err(e) = client_transport.close().await {
|
||||
warn!(%remote_addr, "error closing client transport: {e}");
|
||||
}
|
||||
info!(%remote_addr, "session ended");
|
||||
}
|
||||
None => {
|
||||
// No remote relay configured — just receive and log (sink mode)
|
||||
warn!("no remote relay configured, running in sink mode");
|
||||
loop {
|
||||
match client_transport.recv_media().await {
|
||||
Ok(Some(packet)) => {
|
||||
tracing::trace!(
|
||||
seq = packet.header.seq,
|
||||
block = packet.header.fec_block,
|
||||
"received media packet (sink)"
|
||||
);
|
||||
}
|
||||
Ok(None) => {
|
||||
info!(%remote_addr, "connection closed");
|
||||
break;
|
||||
}
|
||||
Err(e) => {
|
||||
error!(%remote_addr, "recv error: {e}");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user