Repository navigation
[1.1.0] - 2026-11-07
Status: Release candidate
The source version is
1.1.0(project(VERSION)inCMakeLists.txt,
NIMRTC_API_VERSION= 10100,NIMRTC_API_VERSION_PRE_RELEASE="").
Thev1.1/v1.2/v1.3plan drafts were consolidated into
docs/plan/v1.1-plan.md(BDFL, 2026-11-06); the version ladder it
records (§5.6) is:v1.1.0is the only feature-bearing release of the
v1.1line,v1.1.xcarries fixes only, and new behaviour starts at
v1.2.0.The published stable cut is still
v1.0.2; thev1.1.0tag is cut when
the remaining release-hardening gates close (see "Known limitations").
Fixed
-
The GMSSL TLCP backend corrupted the heap on every
open()and crashed
the process.DtlsSessionGmSSLallocated itsTLS_CTXand
TLS_CONNECTobjects in fixed-size byte buffers (128 KiB / 256 KiB) whose
sizes came from stale measurements of an older GmSSL. The real structs are
much larger —sizeof(TLS_CTX)is 201,128 bytes andsizeof(TLS_CONNECT)
is 189,280 bytes on the vendored v3.2.0 tree — and GmSSL's
tls_ctx_init()/tls_init()memsetthe whole struct. The 128 KiB
TLS_CTXbuffer was therefore ~70 KiB too small: thememsetran past
the end of the allocation and smashed the heap, so
test_dtls_gmssl_tlcpdied with a SEGV before the handshake even
started. The buffers are now sized from the realsizeof()plus a 64 KiB
margin, and a compile-time#errorguard makes the build fail loudly if
the GmSSL feature macros (ENABLE_SM9/ENABLE_SECP256R1/ENABLE_LMS
/ENABLE_XMSS/ENABLE_SPHINCS/ENABLE_KYBER) ever stop reaching
this translation unit — those macros decide the size of theX509_KEY
union, so a mismatch would silently change the struct layout and turn
the same memset into heap corruption again. With the fix the TLCP
handshake completes and the whole suite is 697 tests, 0 failures. -
The vendored Opus library was built against a different C runtime than
the rest of the project, so Debug builds crashed on the audio path.
src/third_party/libopus/CMakeLists.txttried to pin the Opus target to
the project's/MDruntime by setting a target property named
CMAKE_MSVC_RUNTIME_LIBRARY— but that is the variable name upstream
reads, not the target property. The property isMSVC_RUNTIME_LIBRARY, so
the override was a silent no-op and upstream's own scope kept the Debug
runtime (MultiThreadedDebugDLL→MSVCRTD) foropus.lib, while every
other NimRTC target usedMultiThreadedDLL→MSVCRT. Linking two CRT
heaps into one program means an allocation in one runtime and the matching
free in the other: the engine tests that touch the Opus path
(test_engine_video_feedbackand its five cases) died with an access
violation beforemain()even printed a line, and the link emitted
LNK4098. The property name is fixed and the compile-flag rewrite now maps
/MTdand/MTto/MD;opus.liband the rest of the tree agree on
MSVCRT, theLNK4098warning is gone, and the full suite is 696 tests,
0 failures. -
Commits and tags were signed with an email GitHub does not recognise, so
every signature showed up as unverified. The release key
114154CFEC3F5EE5A8D2D313BEACFBB55871CC06carried the Gitee noreply
address15608750+video-reflow@user.noreply.gitee.comas its only user ID.
No GitHub account owns that address, so GitHub answeredno_userfor a
signed commit and never rendered a "Verified" badge. The key's user ID is
nowNimRTC Release <realdesktop@163.com>, the account address of
NimRTC, and the key's public block was re-exported with a stock
gpg --exportintobuild/nimrtc-release-signing.pub.asc. The fingerprint
is unchanged, so signatures made before the rename still verify and the
publishedv1.0.2assets keep verifying against the same key; the account's
GitHub GPG key list must be re-pointed at the new block before GitHub
accepts the key (seedocs/plan/v1.1-plan.mdTrack C6). -
The exported public key was not a valid OpenPGP block. The copy on disk
had been written by a PowerShell redirection, which encodes stdout as
UTF-16LE with a BOM; GnuPG rejects it with "partial length invalid for
packet type 63" andgpg --importfails with "Invalid keyring", so no
standard tool could read it. Writing the export through GnuPG's own
--outputflag produces a plain ASCII armoured block that imports cleanly
and whose self-signature reports "Good signature". -
The offline release-signature verifier rejected valid signatures.
tools/verify_release_signature.pyre-implements Ed25519 in pure
Python so a release can be checked without GnuPG. Two defects made
it report every valid signature as invalid: the twisted-Edwards
curve check usedX^2 + Y^2 - Z^2 = d*X^2*Y^2instead of the
RFC 8032 form-X^2 + Y^2 - Z^2 - d*T^2 = 0, and the §5.1.7
equation was checked asR == [S]B + [k]Ainstead of
R + [k]A == [S]B. Both are fixed, and--self-testnow runs the
RFC 8032 §7.1 vectors plus a tampered-signature rejection case, so
the regression cannot come back silently; CI runs it on every push.
With the fix the publishedv1.0.2artefacts all verify (four
detached signatures, four SHA-256 sidecars) — and so does the
signing key's UID self-signature: GnuPG 2.4.8 reports "Good
signature" both for the key import and for every detached
signature, so the publishednimrtc-signing-key.ascneeds no
re-export. -
The release body's 3A status table did not match the published
bundles. The table was derived frombuild/3a-status-<platform>.txt,
which records the build-time APM mode (whether the WebRTC APM
prebuild succeeded), not what the tarball ships. Thev1.0.2body
therefore claimed "WebRTC APM (real 3A) bundled" for the three
platforms whose prebuild had succeeded, while none of the four
published bundles containslib/webrtc_apm/at all, and its
windowsline blamed a failed prebuild although that step succeeded
in the finalv1.0.2release run.release.ymlnow lists the
published tarball and reports the build mode and the shipped content
separately: "real 3A bundled" is only claimed whenlib/webrtc_apm/
is actually inside the artefact, and a platform whose bundle is
missing or carries no APM archives says so. The publishedv1.0.2
body has been corrected accordingly. -
The installed bundle was missing the shared jitter-buffer strategy.
nimrtc::jb_strategy(v1.1 Q2) is linked by bothnimrtc::jband
nimrtc::video_jb, but the install rules did not know about it:
cmake/NimRTCInstall.cmakeshipped neitherlibnimrtc_jb_strategy.a
nor the module's headers, andcmake/NimRTCConfig.cmake.innever
created thenimrtc::jb_strategyimported target. A downstream
consumer that linkednimrtc::jb(or the engine, which fans in every
archive) therefore failed at link time with undefined symbols from
the shared strategy. Both files now carry the module. -
The video jitter buffer silently dropped complete frames. In
video_jb,tick()treated every frame older thanmax_wait_msthe
same way: a frame that never completed was force-emitted (correctly
taggedcomplete = false), but a frame that had completed was
marked as emitted and counted inframes_emittedwithout ever
being handed out — the bitstream was dropped on the floor while
the statistics claimed the frame had been played. The trigger was
rare with the old fixed-window behaviour (the frame was normally
popped long before the timeout), but it becomes the normal case once
a frame waits for its playout deadline, which by design can exceed
max_wait_ms. The timeout now only applies to frames that never
completed; a complete frame stays buffered until it is popped.
Two related defects in the same path are fixed as well: the
in-flight cap evicted the oldest frame unconditionally (so a
complete frame that was only waiting for its deadline could be
evicted by the very delay it was waiting for — the cap now grows
with the adaptive delay window and prefers evicting a frame that
never completed), and a freshly created frame bucket was still
flagged "no marker seen" when the cap ran, so the cap could evict
the frame that had just been inserted. -
The Windows WebRTC APM prebuild reported a successful build as a
failure.tools/build_webrtc_apm.cmdcarried three defects that
together made thewindowsrelease leg fall back to NimRTC's built-in
stub 3A instead of shipping the real AEC/ANS/AGC:- the script was checked out with LF endings (the
* text=autorule
follows the localcore.autocrlfsetting) and cmd.exe mis-parses
an LF-only batch file — it split the quotedvcvars64.batpath at
spaces and never reached the ninja step; - the ninja call was wrapped in
powershell -Commandwith
$ErrorActionPreference = 'Stop', and PowerShell turns a native
command's stderr into error records, so ninja's first progress line
(ninja: Entering directory ...) aborted the wrapper with rc=1; - ninja was invoked without
call, so a.cmd/.batwrapper on
PATH took over control and the script exited silently with no
diagnostic at all.
.gitattributesnow pins*.cmd/*.batto CRLF in the working
tree, the ninja call uses cmd.exe's own redirection
(call ninja -C ... > log 2>&1) so the real exit code survives, and
the failure diagnostics moved from anif (...)block to agoto
label so a syntax error in the triage path can no longer break the
success path. The meson/ninja version echo now runs the tools instead
of expanding!meson --version!as a delayed-expansion variable
reference (which always printed nothing). Verified on Windows/MSVC:
the success path exits 0 and records the link order, the failure path
exits 3 and prints the full ninja log. - the script was checked out with LF endings (the
-
The vendored libjuice tree shipped leftover debug instrumentation.
src/agent.ccarried threeTEMP-DIAGJLOG_INFOblocks (STUN
bookkeeping, per-entry state, retransmit tracing) andsrc/udp.c
carried three per-packetJLOG_INFOblocks (local address,
destination address,sendtoreturn value). All six were compiled
into every NimRTC build — including the published release bundles —
and fired on every STUN keepalive and on every UDP datagram. They are
removed; what remains insrc/udp.cagainst upstream77daa8bis
exactly the intentionalSO_REUSEADDR/SO_REUSEPORTfix from
450dde2, now also preserved as
src/third_party/libjuice/patches/0001-so-reuseaddr.patch. The
em dash in that comment is replaced by a hyphen because MSVC
reported it as C4819 under codepage 936. -
The 3A stage was not doing what its own contract said. Six
separate defects in theaudio3amodule and the engine's use of it
made the real WebRTC APM either inert or actively wrong:- The level meters reported the 3A output, not the input.
capture_level_dbfswas published from the APM's processed
output, so a healthy microphone could read as dead silence: the
noise suppressor legitimately silences a stationary tone (it looks
like noise to a spectral suppressor), the echo canceller
legitimately silences the echo component, and AGC changes the level
by design. A level meter whose reading is a function of the DSP's
decisions cannot answer the only question it exists for ("is the
microphone picking anything up?"). Both meters are now measured in
the input domain — mic level for capture, loudspeaker
reference level for render — and the convention is documented on
LevelStats. report_tx_level = falsestill published a level, and
enable_vad = falsecould still report speech. Both flags are
part of the publicConfig; the stub implementation honoured
neither, so a caller that turned VAD off could still be told the
user was speaking.NullAudio3Anow honours both flags, with the
same semantics as the APM path.- The plugin adapter's level meter never moved.
PluginAdapter
leftConfig::report_tx_levelat its default (false) while
handing the concrete implementation a default configuration, so
stats().last_capture_level_dbfswas permanently -96 dBFS. The
adapter now defaults the concrete configuration to 48 kHz / mono /
level-reporting on, because the plugin'sstats()are the only
way for a host to find out whether the microphone is live. - A degraded backend was indistinguishable from a working one.
When the APM was not part of the build, the factory substituted a
NullAudio3Apassthrough and returned it as an ordinary plugin —
so AEC/ANS/AGC were silently inactive while the call looked
healthy. The fallback now marks the instance as degraded, reports
it inname(), and the engine logs it as an error at start-up.
The newaudio3a::webrtc_apm_compiled_in()tells a caller whether
the build contains the real APM in the first place. - The echo canceller never got a reference signal. The engine
fed the received audio to the host but never to the 3A plugin's
render path, so the APM had no reverse stream and the echo
canceller could not converge at all. The received frame is now
handed toprocess_render()before it reaches the host's playback
callback, andset_render_delivered()follows it so the plugin
can track the system delay. - The APM was told a growing playback counter instead of the
system delay.on_render_delivered()converted the cumulative
count of delivered samples into a millisecond figure and fed that
toset_stream_delay_ms(). The value grew without bound and the
echo canceller cannot use it. The delay is now the measured
loudspeaker-to-microphone latency (Config::aec_delay_headroom_ms),
seeded atinit()and re-seeded after everyreset(). - Samples that straddled a 10 ms APM frame boundary lost their
processed output. The APM only accepts whole frames, so a caller
pushing an arbitrary frame length left a remainder behind; the
carry-over was combined with the next call's head to form a full
frame, but the processed output of the completing call was
never written back into the caller's buffer. Unaligned pushers
therefore got raw audio back with no 3A applied, silently. The
carry-over now accumulates instead of overwriting (no sample is
ever dropped) and the completing call receives its processed
output. The condition is logged once, naming the expected frame
size. - The engine mutated the caller's
constPCM buffer.
send_audio()passed the caller's buffer to the 3A stage, which
processes in place, via aconst_cast— undefined behaviour that
also silently changed the caller's data. The engine now copies
into a buffer it owns, mutates that copy, and encodes from it.
Verified locally on Windows/MSVC with the real APM compiled in: the
full suite is 642 tests, 0 failures. The nineaudio3atests that
need the real APM (Audio3AFrameAlignment,Audio3AConfig,
Audio3AStartup,Audio3ARenderPath,Audio3ADegradation) run
instead of skipping whenNIMRTC_VENDORED_WEBRTC_APM=ON; they skip
when the build has no APM, which is the pre-existing contract. - The level meters reported the 3A output, not the input.
-
The DTLS in-process AEAD test did not compile on MSVC. The
previous commit replaced the hard-coded key length16with the
kAesKeyLenconstant — but that constant lives inside
namespace nimrtc, and the test'smain()sits at global scope
after that namespace closes, so the unqualified use did not resolve
and MSVC reported C2065 "undeclared identifier" (plus the
knock-on C3536/C2660). The file is#ifdef _WIN32-only, so the
Linux and macOS CI legs compiled it to an empty translation unit and
stayed green: only the Windows leg could see the break. The uses are
now qualified asnimrtc::kAesKeyLen. -
Two concurrent NimRTC processes on one host fought over usrsctp's
shared UDP port. The SCTP seam calledusrsctp_init(9899, ...)
with a fixed port, and usrsctp'srecv_thread_init()binds its
internaluserspace_udpsctpsocket to exactly that port. When a
second process on the same host started, itsbind()failed, its
socket stayed invalid, and its SCTP packets went to 127.0.0.1:9899 —
which belonged to the first process. usrsctp's listener
demultiplexed those datagrams onto the wrong socket, so the
INIT/INIT-ACK handshake never completed and the test timed out after
60 s. This is not theoretical: CTest runs each gtest-discovered case
as its own process under-j 2, and the Linux CI leg of 2026-11-07
showedSctpUsrsctpTest.PartialReliableTtlDroptiming out at 60 s
while a sibling case passed in 0.9 s. The seam now picks a free
ephemeral UDP port per process (nimrtc_pick_free_udp_port()) and
records it so the per-socketSCTP_REMOTE_UDP_ENCAPS_PORTmatches
what usrsctp actually bound; the port is no longer cleared when the
last socket goes away, because the listener lives for the whole
process lifetime.
Changed
-
The seven-day soak window now measures the release candidate's tree,
notmain. Thev1.1.0tag is cut fromrelease/1.1, andmain
already carries the v1.2.0 audio body, so evidence collected from
mainwould have been evidence about a different program than the one
being released. Three changes close the gap:.github/workflows/soak.ymlgained aSOAK_REFenvironment
variable (${{ inputs.ref || 'release/1.1' }}) and a matchingref:
on both checkouts, so the scheduled run measuresrelease/1.1and a
manual run can point it elsewhere through the newrefdispatch
input. The workflow's two jobs are therefore the pinned source of
both halves of the window.tools/run_soak.pynow records the tree each run was measured on
(git_refandgit_commit) in every evidence record, and its
summary only counts a day as green when that tree is the candidate
branch (--expect-ref, defaultrelease/1.1). A day measured on
main— which is what the local Scheduled Task produces whenever
the release machine's checkout is onmain— is listed as "measured
on another tree" rather than silently credited to the window.
Evidence written before the collector tracked the tree has no
git_refand is therefore not green either, so the window restarts
from zero.tools/run_soak.py --self-testnow runs on every push
(.github/workflows/ci.yml), pinning the streak semantics and the
new tree rule together: a window measured on the wrong tree must
fail the gate.
docs/plan/soak-runbook.md§4.3.1 records which tree each half of
the window measures and how to check the local one. -
The soak window also refuses to credit a day that was measured on a
dirty working tree. A commit identifies a tree, but a dirty tree is
not that tree: the program that produced the evidence is whatever the
working directory happened to contain, so such a day says nothing
about the commit that gets tagged.tools/run_soak.pynow records
git_dirtyin every evidence record, and a day whose records are not
all from a clean tree is not green — it is listed under "days
measured on an unclean tree". A record that does not say (one written
before the flag existed) is reported as "not recorded" rather than as
dirty, because the gate cannot certify what it cannot see. -
The daily Windows evidence run is now a script rather than a
hand-typed Scheduled Task action.scripts/run-soak-daily.ps1runs
the collector, tees its output intobuild/soak/soak-task.logand
returns the collector's exit code; it picks the first interpreter that
can both execute code and importplaywright, because Case D drives
a real Chrome peer through Playwright and an interpreter without it
produces no evidence at all.scripts/register-soak-task.ps1
registers (or removes) the task, warns when the checkout is not on
the candidate branch, and usesStartWhenAvailableso a trigger
missed while the machine was asleep fires on wake — a gap day breaks
the streak, so a task that never runs is worse than one that runs
late. -
The source version is now
1.1.0(project(VERSION)in
CMakeLists.txt,NIMRTC_API_VERSION_{MAJOR,MINOR,PATCH}in
src/core/include/nimrtc/core/api_version.hpp, encodedNIMRTC_API_VERSION
10002→10100). The three formerv1.1/v1.2/v1.3plan drafts
are consolidated into onedocs/plan/v1.1-plan.mdtargetingv1.1.0
(BDFL, 2026-11-06): they all described a single unreleased body of work on
top of the publishedv1.0.2, and numbering them as three consecutive
versions implied three releases' worth of roadmap without three releases'
worth of delivered versions. The published stable cut is stillv1.0.2;
v1.1.0is the version under preparation and its tag is cut only once the
release-hardening track (docs/plan/v1.1-plan.mdTrack C) closes. -
The
cloudgameProfile was never shipped, and the docs said it was.
README.md,README.zh.md,docs/profiles.md,docs/zh/architecture.md
anddocs/blog/2026-10-10-why-nimrtc.{md,zh.md}all listedcloudgame
as an available Profile — butprofiles/cloudgame.jsondoes not exist and
assemblyhas nokProfileCloudGame; the registry ships 9 profiles.
BDFL decided on 2026-11-04 thatcloudgamedoes not enter the official
Profile combination and is deferred to v1.2+, because its hardest
differentiator ("input aligned to the render frame") needs a render
timestamp from the rendering host (Unreal / Unity), which is outside the
engine's boundary — the engine does not bundle codecs, and GPU encode /
render-pipeline integration is out of scope. The remaining three
overrides are already covered by theteleopfamily plus the
command-to-frame API. The primary scenes are now AI Agent (agent/
agent-gateway/agent-low-latency/relay-agent) and embodied-AI
teleoperation (teleop, same family, no new Profile);
takeover(remote vehicle takeover) stays P4. All affected documents now
statecloudgameas a long-term candidate that is not in the shipped
Profile set.docs/plan/v1.1-plan.md§2 Track V item V2 is now a
documentation-alignment task rather than a Profile implementation. -
The GM/T coverage claim was overstated. README (EN + ZH) and the
architecture doc described the project as "GM/T cryptography ready" /
"GM/T 国密就绪", which implies end-to-end GM/T media encryption. The
engine's GM/T path covers the DTLS handshake (TLCP / SM2 / SM3 / SM4
via the GMSSL backend); SRTP still uses the international AES suites
(SM4-GCM SRTP is a later release — alibSRTP-free implementation would
have to re-derive RFC 3711's KDF with SM3 as the PRF, and D1 forbids
self-implementing security-critical crypto). The claims are now scoped
explicitly, which matters because the previous wording was a compliance
misstatement towards regulated / Xinchuang customers. The compliance
layering is documented indocs/plan/v1.1-plan.md§2 Track X: signalling
TLCP is above the engine (§10 already says "上层"), DTLS GM/T is
inside the engine, SRTP GM/T is inside the engine but not yet
implemented. -
ADR-013's "do not vendor GMSSL" premise was stale. Its decision
clause 6 justified the system-install-only strategy by "keeping
consistency with wolfSSL (which is also not vendored)" — but wolfSSL has
since become a real git submodule, as have msquic / libsrtp / libopus.
Requiring every downstream integrator to build and install GMSSL into
their own sysroot is exactly the integration burden ADR-013 set out to
remove (OHOS / aarch64 cross-compilation cannot reasonably assume a
system-installed GMSSL). The decision is therefore amended (2026-11-04):
GMSSL becomes a git submodule undersrc/third_party/gmssl, built via
add_subdirectorywhenNIMRTC_ENABLE_DTLS_GMSSL=ON, with the option
still defaulting to OFF so the default build's output size, build
time and artifact set are unchanged. Vendoring is gated on verifying the
pinned commit's LICENSE text and recording it invendor.json; the
acceptance criteria now include a Windows/MSVC compile, since GMSSL v3 is
known to be rougher there and "works out of the box" does not hold on
Windows until that is proven. -
libsrtp is now a real git submodule. The vendored tree at
src/third_party/libsrtp/srcwas byte-identical to upstream
2f82ec0e6e55a18d9cfae2001a4b3fbbc0049da2, so it converted with no
NimRTC-local patch to carry over: the parent repository now tracks
the path as a gitlink (index mode160000) instead of ~2400 checked-in
files..gitmodulesgains the real entry
(https://github.com/cisco/libsrtp.git, branchmain), the nested
clone's git dir was absorbed into.git/modules/, andvendor.json
records the conversion (upstream_versioncorrected frommasterto
main, notes rewritten).tools/check_vendor.pynow reports
libsrtpasok— a verified submodule — rather than
vendored-tree.docs/plan/vendor-migration.md§3 Phase 3 marks
libsrtp converted. Windows proof 2026-11-03: full Debug build
green,ctest629/629 passed,test_srtp_test8/8 passed. -
The vendor manifest now tells the truth about what is a submodule.
tools/check_vendor.pydistinguishes a registered submodule (a
gitlink, index mode160000) from a vendor whose sources are still
checked into this repository; the latter is now reported as
vendored-treeinstead of being counted as a verified submodule.
.gitmodulesno longer listslibjuiceandmbedtls, which have no
gitlink in the index (their intended settings are kept as comments,
with the blocker for each conversion spelled out).
vendor.jsonrecords the state and the local deltas per vendor, and
src/third_party/SOURCE_VERSIONS— which claimed to be copied
verbatim fromvendor.jsonbut was not — is corrected: libopus now
points at22244de, googletest at thev1.12.0revision upstream
actually tags, andmsquicis listed at all.
Added
-
The weak-network baseline facility landed (v1.1 Track Q4, "弱网基线设施").
Two reproducible paths measure the same three tiers — 5% loss,
20 ms base + 0–100 ms jitter, 1 Mbps cap — over a 1200 B payload:tools/benchmark_weaknet.pyis the portable path: an in-process
userspace shaper between two loopback UDP sockets with seeded
(deterministic) impairments, so Windows/macOS/Linux all reproduce
the same numbers without root.tools/benchmark_weaknet_netem.shis the Linux path: the same
tiers driven by a realtc qdisc netemqdisc attached tolo
inside a throwaway network namespace (so the host's loopback is
never reshaped). The tool's--mode netemthen only paces the
sends and measures arrival-minus-send — the impairments are the
kernel's.- Both account in wire bytes and keep the offered load at 90%
of the capacity. A rate-limited link delays a packet by its base
delay plus the time it needs to put the packet on the wire (the
serialization time), not by the delay alone; the old revision
paced at 100% of the cap and omitted the serialization term, so
the "1 Mbps" tier reported a queue the sender had built up itself
rather than the link's delay. The capped tier now reads
~15 ms (5 ms base + ~9.6 ms serialization) with a flat
distribution (p99 − p50 < 2 ms) instead of ~16–31 ms with a
queue-dependent tail. - The netem script pins the qdisc's cell size to 1 byte
(rate 1mbit 0 1): netem rounds the charged length up to the
cell size, and with the default cell the charge no longer matches
the length the sender paces against. - Two Windows-only measurement defects were fixed. The shaper
scheduled its delivery deadlines ontime.monotonic(), which on
Windows isGetTickCount64with a 15.6 ms resolution, so
every packet's delay was quantized to a 15.6 ms step; it now uses
time.perf_counter()(QueryPerformanceCounter). And the
forwarder waited for its deadline withCondition.wait(timeout=…),
whose timed wake-up has a ~10 ms granularity on Windows (a 10 ms
wait returns after ~20 ms), which added 5–15 ms of lateness to
every packet; it now polls in 0.5 ms slices outside the lock. - CI runs the netem path on the Linux x86_64 leg (
sudo, needs
iproute2); the JSON lands inbuild/e2e/bench_weaknet_netem.json
next to the portablebuild/e2e/bench_weaknet.json. - README (EN + 中文) Benchmarks tables now quote the corrected
numbers for both paths.
-
The RTCP feedback loop is closed (v1.1 Track Q3, "RTCP 反馈闭环打通").
nimrtc::video_rtcp_feedback(NACK / FIR / PLI) is now wired to the
video pipeline, so a lost packet travels the whole path:- the receiver detects the RTP sequence-number gap and reports it
through the newVideoReceiver::set_feedback_callback()(plain
data: the lost sequence numbers, plus a key-frame request when
picture data was lost) —ReceiverStats:: keyframe_requests_emittedcounts the latter; video_pipeline::build_feedback_rtcp()encodes the report as RTCP
bytes (a NACK per RFC 4585 §6.2.1, a PLI per RFC 4585 §6.3.1);
video_pipeline::feedback_rtcp_size()sizes the destination, and a
report that does not fit is rejected as a whole (nothing is
written);- the sender keeps the packets it sent in a bounded ring buffer
(SenderConfig::retransmit_cache_packets, default 256) and
VideoSender::retransmit()re-sends the exact packet that was
lost — same sequence number, timestamp and marker bit; video_pipeline::apply_feedback_rtcp()closes the loop on the
sender side: a NACK triggers the retransmissions, a PLI or FIR
arms the sender's key-frame marker (VideoSender:: force_keyframe()/keyframe_pending()), and a compound RTCP
packet is processed as a whole.- the wire format gained the two helpers it was missing:
video_rtcp_feedback::pack_nack_entries()packs a list of lost
sequence numbers into PID + BLP FCI entries (wrap-aware: a loss set
straddling the 65535 → 0 rollover still fits in one entry), and
unpack_nack_entries()expands them back. - the plugin seam follows:
ReceiverAdapter::set_nack_callback()
now forwards the receiver's loss reports to the engine instead of
only storing the callback, andplugins::VideoReceiverStats/
VideoSenderStatsexpose the new counters
(keyframe_requests_emitted,packets_retransmitted,
packets_retransmit_missed). - the engine owns the RTCP transport, so the two halves are wired
there: the receiver's report is queued by
VideoReceiver::set_feedback_callback()and put on the wire from
NimRTCEngine::tick()as SRTCP (RFC 3711 §3.4 — a different crypto
context from SRTP, soprotect_rtcp()and notprotect_rtp());
inbound RTCP is handed to the sender through
IVideoSender::apply_feedback_rtcp(), and a key-frame request is
forwarded to the encoder (force_keyframe()), because the
packetizer alone cannot produce an IDR. The feedback is sent from
tick()rather than from the receive callback so the transport's
send()is never re-entered from itsrecv(). - The new
tests/test_video_feedback_loop.cppcovers the closed loop
end to end (loss → NACK → retransmission → re-delivery, and PLI →
key frame). - The new
tests/test_engine_video_feedback.cppcovers the engine
half of the loop, which the module-level tests cannot reach: the
engine is driven through a fake ICE transport (registered under the
id "fake-ice") that captures every outbound datagram and can inject
inbound ones, so the test asserts on the wire that a detected loss
really becomes an RTCP NACK (naming the peer's media SSRC and the
lost sequence number), that an inbound NACK really produces a
retransmission carrying the original sequence number, that an inbound
PLI really reaches the encoder'sforce_keyframe(), and that an
unrelated RTCP packet (a Receiver Report) is left alone.
- the receiver detects the RTP sequence-number gap and reports it
-
The video jitter buffer now shares the audio side's adaptive
playout strategy (v1.1 Track Q2, "视频侧自适应 JB 统一"). The
RFC 3550 §6.4.1 interarrival-jitter estimator and the
"base + 4·J" target-delay policy live once, in the new
nimrtc::jb_strategymodule;nimrtc::jb(audio) and
nimrtc::video_jb(video) are now two front-ends of that one
strategy. The video front-end:- feeds the estimator once per frame (a video frame — not an RTP
packet — is what the decoder plays out, and the packets of one
frame share a media-clock reading, so per-packet observations
would feed the estimator the intra-frame burst spread and bias the
jitter estimate upwards); - holds a complete frame until its playout deadline (first-packet
arrival + target delay) has passed, with the deadline derived from
the smoothed jitter estimate and clamped to
[min_delay, max_delay]; the delay and jitter estimates are
published throughvideo_jb::Stats; - is opt-in (
Config::adaptive, default off): with the default
configuration a complete frame is still delivered the moment it is
assembled, so the receive path keeps its current latency. The
engine exposes the switch through
EngineConfig::video_receiver_tuning.adaptive_playoutand
plugins::VideoReceiverConfig::adaptive_playout; - gained a time-aware
pop_frame(now_us)overload; the no-argument
pop_frame()keeps its "hand out the next complete frame"
behaviour, so existing callers are unaffected.
- feeds the estimator once per frame (a video frame — not an RTP
-
The Goog-CC bandwidth estimator landed alongside AIMD (v1.1 Track
Q1, "BWE 主线升级").src/modules/bwe/gainsGoogCcBwe, a
delay-plus-loss hybrid estimator registered under the factory id
"goog-cc"; AIMD stays the default backend, and
EngineConfig::bwe_nameopts in explicitly, so existing sessions
keep their behaviour unless the caller asks for the new path. RTT /
loss / probe feedback reach the estimator through the existing BWE
input path, andtests/test_bwe.cppcovers bandwidth ramp-up,
loss-triggered downshift and probe feedback. -
The frame↔capture-timestamp map is now an engine API (v1.1 Tracks
T1/T2, "ref_frame引擎级暴露 / 命令-画面关联").
NimRTCEngineexposes the bidirectional mapping as additive
NIMRTC_API_UNSTABLEmethods —record_video_ref_frame()mounts a
frame id,ref_frame_to_capture_ts()/capture_ts_to_ref_frame()
resolve it in either direction, anddata_message_frame_age_us()
answers "which frame does this data message target, and how old is
it". The map is a bounded 1024-entry ring;send_video()and the
receive callback record automatically.tests/test_engine_ref_frame.cpp
covers mount / reverse lookup / miss / age / eviction. -
NimRTCEngine::stats()now aggregates the video counters (v1.1
Track V1, "video_stats进 engine"). The eight module-level video
counters (bitrate / dropped frames / NACK classification) are summed
into the engine stats view additively — zero-valued when no video
flows, so existing consumers see no change. -
GMSSL is a real git submodule (v1.1 Track X1).
src/third_party/gmssl
pins GmSSL v3.2.0 (.gitmodules+vendor.jsonin sync; the pinned
LICENSE text verified Apache-2.0-compatible and recorded in
vendor.json).NIMRTC_ENABLE_DTLS_GMSSL=ONbuilds it via
add_subdirectorywith no system-install probing; the default stays
OFF so the default build is unchanged. CI carries the opt-in
gmssl-vendored/msvclegs runningtest_dtls_gmssl_tlcp. -
The SRTP backend seam landed; SM4-GCM stays v1.2+ (v1.1 Track X2).
src/plugins/include/nimrtc/plugins/srtp_backend.hppdeclares the
additiveISrtpSessionBackend+ factory seam, and
src/modules/srtp/routes the existing libsrtp path through a
libsrtp_backendadapter — behaviour unchanged. SM4-GCM SRTP is
explicitly out of scope for v1.1 (workload + D1 "no self-built
security-critical crypto"); the README national-crypto claim is
scoped to "DTLS/TLCP covered, SRTP still international suites". -
The engine translation unit is split five ways, behaviour unchanged
(v1.1 Track R1).src/engine/src/engine.cpp(~4.5 kLOC) becomes
five responsibility-grouped TUs sharing the private
src/engine/src/engine_impl.hpp(core / transport / media /
signaling / timeline); the publicengine.hppis untouched (L4).
Verified 2026-11-05 on Windows/MSVC: full build exit 0, full
ctest696/696, freeze scan headers 106 / symbols 707 / missing 0. -
Track D packaging rules landed (behind
NIMRTC_INSTALL=OFFby
default).cmake/NimRTCInstall.cmake(new) centralises the Track D
install()coverage from one place instead of touching every
per-moduleCMakeLists.txt: it installs everysrc/*/include+
src/modules/*/includetree to<prefix>/include/, every built
nimrtc_*STATIC archive (plusopusandnimrtc_vendor_usrsctp,
which have no upstream install coverage) to<prefix>/lib/, and a
hand-writtenNimRTCConfig.cmake+SameMajorVersionversion file
to<prefix>/lib/cmake/NimRTC/.release.ymlalready passes
-DNIMRTC_INSTALL=ONon all five configure legs; the top-level
CMakeLists.txtonly adds theNIMRTC_INSTALLoption and
include(NimRTCInstall). Windows downstream proof verified
2026-11-03:cmake --installstaging holdsinclude/+lib/+
lib/cmake/NimRTC/, and a minimalfind_package(NimRTC 1.0 REQUIRED)
consumer linkingnimrtc::engineconfigures, builds, and runs exit 0
(Linux downstream proof runs inci.ymlon every push via the
install + downstream-proof leg;## [1.1.0]is cut when the remaining
C-track gates — the 7-day soak and the signed tag — clear). -
The installed bundle now carries the WebRTC APM prebuilt. The
APM is built out-of-tree with Meson and has no upstreaminstall()
rules, so the bundle used to ship without
libwebrtc-audio-processing-2.aand the abseil archives it
references: a downstream consumer linkingnimrtc::enginefailed
with unresolvedwebrtc::/absl::symbols. The archive set and
their order now come from the Meson build's own link line, recorded
by the newtools/apm_link_order.pyinto
build_meson/apm_link_order.txt(a static linker resolves symbols
left-to-right, so the order is part of the contract). The build-tree
CMake wrapper reads that manifest instead of globbing abseil
archives in alphabetical order,cmake/NimRTCInstall.cmakeships
the archives to<prefix>/lib/webrtc_apm/together with the order
manifest, and the installedNimRTCConfig.cmakechains them in that
order.tools/build_webrtc_apm.{cmd,sh}run the helper as a final
step and fail with exit code 4 if the order cannot be recorded.
Windows downstream proof verified 2026-11-04: the staging tree
holds 13 archives underlib/webrtc_apm/, and a minimal
find_package(NimRTC 1.0 REQUIRED)consumer linking
nimrtc::enginelinks against the real APM and runs exit 0 with
"real WebRTC APM" initialised (AEC/ANS/AGC). -
Track A bench CI artifacts (
b628fcb).ci.ymlwindows/msvc and
linux-gcc legs now runtools/benchmark_latency.py --count 1000+
tools/benchmark_dc.pyand uploadbuild/e2e/bench_latency.json+
build/e2e/bench_dc.jsonasbench-<platform>-${{ github.run_id }}
artifacts (14-day retention). Linux x86_64 reproducibility evidence
still pending the first green run after this commit;## [1.1.0]is cut
when the remaining C-track gates — the 7-day soak and the signed tag —
clear (W3 and W5 are closed). -
Track A reproducible baselines (v1.1 A1/A2). New
tools/benchmark_dc.pybursts N UDP datagrams per payload size
over 127.0.0.1 (256/1200 B datagram plane, 16384 B bidi-stream-chunk
plane) and emitsbuild/e2e/bench_dc.jsonwith pps + Mbps per size.
README Benchmarks (EN + ZH) now cites measured transport-floor
numbers forbench_latency.json+bench_dc.jsonwith reproduce
commands. Re-verified 2026-11-02 on Windows 10 x86_64: latency
p50 ~9.7 µs / p99 ~17.2 µs / jitter ~0.2 µs (1000 × 172 B); DC
256 B ~74.8k pps / ~153 Mbps, 1200 B ~76.6k pps / ~735 Mbps,
16384 B bidi-stream-chunk ~67.1k pps / ~8.8 Gbps (2000 msgs each);
all inside the README cited ranges. -
Track B timeline收尾 B3 (docs only, no new seam).
docs/plan/timeline-engine-wiring.mdstep 4 now records the
long-session slope quality note (sub-ms for minutes, degrades
after; single-SR fallback) plus the paired DTLS/SRTP timeline e2e
gap (feed_srtp_inbound()needs a completed handshake).
ADR-017 Consequences already carried the same two statements, so
B1/B2 have no stale "always 0" / "single-SR only" text left. -
Track A size bench A3.
python tools/benchmark_size.py --markdownreports static libnimrtc_engine12.46 MB (<15 MB);
matches the README static-lib claim. Freeze script
scripts/check-release-freeze.shpasses 6/6 (additive-only API).
Known limitations (v1.1 C-track, still open)
-
W3 is closed 2026-11-06: the
Prebuild WebRTC APMstep lost
continue-on-erroron all four release legs and Configure is pinned to
a literal-DNIMRTC_VENDORED_WEBRTC_APM:BOOL=ON, so every bundle ships
the real WebRTC APM 3A and a prebuild regression aborts the cut instead
of degrading it to the built-in stub 3A path. W5 was closed 2026-11-05
(review) — thev1.0.2release published the aarch64 bundle, so
build-linux-aarch64is a hard gate again (nocontinue-on-error, back
inpublish-release.needs).docs/plan/ci-workarounds.mdW3/W5 remain
the source of truth. -
Still open before the
v1.1.0tag: the 7-day soak evidence for
§12.3.6 Gate 6, and the signed annotated tag itself. The upload of
the release key to the GitHub account GPG list is no longer a
blocker: the repository signs tags withgpg.format = sshand the
account's already-registered SSH key, so GitHub renders the tag as
"Verified" without it (RELEASING.md§3.3 step 11;docs/plan/ v1.1-plan.mdTrack C6, 2026-11-06). The OpenPGP path remains
available and would need the key on the GPG list for its badge.
The soak window restarts from zero because it now measures the
candidate treerelease/1.1rather thanmain(see the "Changed"
entry onSOAK_REFabove): the 2026-11-06 / 2026-11-07 records were
taken frommain, whose tree already carried the v1.2.0 audio body,
and the Linux half of that window was red anyway — the Linux port
picker crashed and the CI evidence was not merged into the
summary, and both fixes are onrelease/1.1. The first counted day
is 2026-11-08 (UTC), and the earliest possible close of the window
is 2026-11-14 — seven consecutive green Case D + Case E days on
both platforms, with every record taken on a clean checkout of
release/1.1. -
The earlier C-track notes that kept W3 / W5 open are superseded.
W3 (Windows APM prebuildcontinue-on-error) and W5
(build-linux-aarch64soft gate) were closed on 2026-11-06 and
2026-11-05 respectively;docs/plan/ci-workarounds.mdW3/W5 remain the
source of truth.
Verifying the signature
The public half of the signing key ships with this
release asnimrtc-signing-key.asc. To verify a bundle:
gpg --import nimrtc-signing-key.asc gpg --verify nimrtc-<version>-<platform>.tar.xz.asc nimrtc-<version>-<platform>.tar.xz
The signing key fingerprint is
114154CFEC3F5EE5A8D2D313BEACFBB55871CC06.
Check it against the fingerprint shown bygpg --fingerprint
after importing — do not trust the key file blindly.
3A (AEC/ANS/AGC) status per platform
linux-aarch64— the build used the real WebRTC APM, but this bundle ships no APM archives (lib/webrtc_apm/is absent), so it provides no usable 3Alinux-x86_64— the build used the real WebRTC APM, but this bundle ships no APM archives (lib/webrtc_apm/is absent), so it provides no usable 3Amacos-arm64— the build used the real WebRTC APM, but this bundle ships no APM archives (lib/webrtc_apm/is absent), so it provides no usable 3Awindows— the build used the real WebRTC APM, but this bundle ships no APM archives (lib/webrtc_apm/is absent), so it provides no usable 3A
The WebRTC APM is prebuilt out-of-tree with meson. Where
that prebuild fails, the build falls back to NimRTC's
built-in stub 3A path instead of aborting the release.
The status above is checked against the published bundle:
a platform counts as "real 3A bundled" only when
lib/webrtc_apm/is actually present in the tarball.