Skip to content

NimRTC v1.1.0

Latest

Choose a tag to compare

@github-actions github-actions released this 09 Nov 04:37
· 150 commits to main since this release
v1.1.0
50358b8

[1.1.0] - 2026-11-07

Status: Release candidate

The source version is 1.1.0 (project(VERSION) in CMakeLists.txt,
NIMRTC_API_VERSION = 10100, NIMRTC_API_VERSION_PRE_RELEASE = "").
The v1.1 / v1.2 / v1.3 plan drafts were consolidated into
docs/plan/v1.1-plan.md (BDFL, 2026-11-06); the version ladder it
records (§5.6) is: v1.1.0 is the only feature-bearing release of the
v1.1 line, v1.1.x carries fixes only, and new behaviour starts at
v1.2.0.

The published stable cut is still v1.0.2; the v1.1.0 tag 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.
    DtlsSessionGmSSL allocated its TLS_CTX and
    TLS_CONNECT objects 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 and sizeof(TLS_CONNECT)
    is 189,280 bytes on the vendored v3.2.0 tree — and GmSSL's
    tls_ctx_init() / tls_init() memset the whole struct. The 128 KiB
    TLS_CTX buffer was therefore ~70 KiB too small: the memset ran past
    the end of the allocation and smashed the heap, so
    test_dtls_gmssl_tlcp died with a SEGV before the handshake even
    started. The buffers are now sized from the real sizeof() plus a 64 KiB
    margin, and a compile-time #error guard 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 the X509_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.txt tried to pin the Opus target to
    the project's /MD runtime by setting a target property named
    CMAKE_MSVC_RUNTIME_LIBRARY — but that is the variable name upstream
    reads, not the target property. The property is MSVC_RUNTIME_LIBRARY, so
    the override was a silent no-op and upstream's own scope kept the Debug
    runtime (MultiThreadedDebugDLL → MSVCRTD) for opus.lib, while every
    other NimRTC target used MultiThreadedDLL → 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_feedback and its five cases) died with an access
    violation before main() even printed a line, and the link emitted
    LNK4098. The property name is fixed and the compile-flag rewrite now maps
    /MTd and /MT to /MD; opus.lib and the rest of the tree agree on
    MSVCRT, the LNK4098 warning 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
    114154CFEC3F5EE5A8D2D313BEACFBB55871CC06 carried the Gitee noreply
    address 15608750+video-reflow@user.noreply.gitee.com as its only user ID.
    No GitHub account owns that address, so GitHub answered no_user for a
    signed commit and never rendered a "Verified" badge. The key's user ID is
    now NimRTC Release <realdesktop@163.com>, the account address of
    NimRTC, and the key's public block was re-exported with a stock
    gpg --export into build/nimrtc-release-signing.pub.asc. The fingerprint
    is unchanged, so signatures made before the rename still verify and the
    published v1.0.2 assets 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 (see docs/plan/v1.1-plan.md Track 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" and gpg --import fails with "Invalid keyring", so no
    standard tool could read it. Writing the export through GnuPG's own
    --output flag 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.py re-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 used X^2 + Y^2 - Z^2 = d*X^2*Y^2 instead of the
    RFC 8032 form -X^2 + Y^2 - Z^2 - d*T^2 = 0, and the §5.1.7
    equation was checked as R == [S]B + [k]A instead of
    R + [k]A == [S]B. Both are fixed, and --self-test now 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 published v1.0.2 artefacts 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 published nimrtc-signing-key.asc needs no
    re-export.

  • The release body's 3A status table did not match the published
    bundles.
    The table was derived from build/3a-status-<platform>.txt,
    which records the build-time APM mode (whether the WebRTC APM
    prebuild succeeded), not what the tarball ships. The v1.0.2 body
    therefore claimed "WebRTC APM (real 3A) bundled" for the three
    platforms whose prebuild had succeeded, while none of the four
    published bundles contains lib/webrtc_apm/ at all, and its
    windows line blamed a failed prebuild although that step succeeded
    in the final v1.0.2 release run. release.yml now lists the
    published tarball and reports the build mode and the shipped content
    separately: "real 3A bundled" is only claimed when lib/webrtc_apm/
    is actually inside the artefact, and a platform whose bundle is
    missing or carries no APM archives says so. The published v1.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 both nimrtc::jb and
    nimrtc::video_jb, but the install rules did not know about it:
    cmake/NimRTCInstall.cmake shipped neither libnimrtc_jb_strategy.a
    nor the module's headers, and cmake/NimRTCConfig.cmake.in never
    created the nimrtc::jb_strategy imported target. A downstream
    consumer that linked nimrtc::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 than max_wait_ms the
    same way: a frame that never completed was force-emitted (correctly
    tagged complete = false), but a frame that had completed was
    marked as emitted and counted in frames_emitted without 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.cmd carried three defects that
    together made the windows release 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=auto rule
      follows the local core.autocrlf setting) and cmd.exe mis-parses
      an LF-only batch file — it split the quoted vcvars64.bat path at
      spaces and never reached the ninja step;
    • the ninja call was wrapped in powershell -Command with
      $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/.bat wrapper on
      PATH took over control and the script exited silently with no
      diagnostic at all.

    .gitattributes now pins *.cmd / *.bat to 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 an if (...) block to a goto
    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 vendored libjuice tree shipped leftover debug instrumentation.
    src/agent.c carried three TEMP-DIAG JLOG_INFO blocks (STUN
    bookkeeping, per-entry state, retransmit tracing) and src/udp.c
    carried three per-packet JLOG_INFO blocks (local address,
    destination address, sendto return 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 in src/udp.c against upstream 77daa8b is
    exactly the intentional SO_REUSEADDR/SO_REUSEPORT fix 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 the audio3a module 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_dbfs was 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 = false still published a level, and
      enable_vad = false could still report speech. Both flags are
      part of the public Config; the stub implementation honoured
      neither, so a caller that turned VAD off could still be told the
      user was speaking. NullAudio3A now honours both flags, with the
      same semantics as the APM path.
    • The plugin adapter's level meter never moved. PluginAdapter
      left Config::report_tx_level at its default (false) while
      handing the concrete implementation a default configuration, so
      stats().last_capture_level_dbfs was permanently -96 dBFS. The
      adapter now defaults the concrete configuration to 48 kHz / mono /
      level-reporting on, because the plugin's stats() 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
      NullAudio3A passthrough 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 in name(), and the engine logs it as an error at start-up.
      The new audio3a::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 to process_render() before it reaches the host's playback
      callback, and set_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
      to set_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 at init() and re-seeded after every reset().
    • 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 const PCM buffer.
      send_audio() passed the caller's buffer to the 3A stage, which
      processes in place, via a const_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 nine audio3a tests that
    need the real APM (Audio3AFrameAlignment, Audio3AConfig,
    Audio3AStartup, Audio3ARenderPath, Audio3ADegradation) run
    instead of skipping when NIMRTC_VENDORED_WEBRTC_APM=ON; they skip
    when the build has no APM, which is the pre-existing contract.

  • The DTLS in-process AEAD test did not compile on MSVC. The
    previous commit replaced the hard-coded key length 16 with the
    kAesKeyLen constant — but that constant lives inside
    namespace nimrtc, and the test's main() 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 as nimrtc::kAesKeyLen.

  • Two concurrent NimRTC processes on one host fought over usrsctp's
    shared UDP port.
    The SCTP seam called usrsctp_init(9899, ...)
    with a fixed port, and usrsctp's recv_thread_init() binds its
    internal userspace_udpsctp socket to exactly that port. When a
    second process on the same host started, its bind() 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
    showed SctpUsrsctpTest.PartialReliableTtlDrop timing 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-socket SCTP_REMOTE_UDP_ENCAPS_PORT matches
    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,
    not main.
    The v1.1.0 tag is cut from release/1.1, and main
    already carries the v1.2.0 audio body, so evidence collected from
    main would have been evidence about a different program than the one
    being released. Three changes close the gap:

    • .github/workflows/soak.yml gained a SOAK_REF environment
      variable (${{ inputs.ref || 'release/1.1' }}) and a matching ref:
      on both checkouts, so the scheduled run measures release/1.1 and a
      manual run can point it elsewhere through the new ref dispatch
      input. The workflow's two jobs are therefore the pinned source of
      both halves of the window.
    • tools/run_soak.py now records the tree each run was measured on
      (git_ref and git_commit) in every evidence record, and its
      summary only counts a day as green when that tree is the candidate
      branch (--expect-ref, default release/1.1). A day measured on
      main — which is what the local Scheduled Task produces whenever
      the release machine's checkout is on main — 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_ref and is therefore not green either, so the window restarts
      from zero.
    • tools/run_soak.py --self-test now 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.py now records
    git_dirty in 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.ps1 runs
    the collector, tees its output into build/soak/soak-task.log and
    returns the collector's exit code; it picks the first interpreter that
    can both execute code and import playwright, 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 uses StartWhenAvailable so 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, encoded NIMRTC_API_VERSION
    10002 → 10100). The three former v1.1 / v1.2 / v1.3 plan drafts
    are consolidated into one docs/plan/v1.1-plan.md targeting v1.1.0
    (BDFL, 2026-11-06): they all described a single unreleased body of work on
    top of the published v1.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 still v1.0.2;
    v1.1.0 is the version under preparation and its tag is cut only once the
    release-hardening track (docs/plan/v1.1-plan.md Track C) closes.

  • The cloudgame Profile was never shipped, and the docs said it was.
    README.md, README.zh.md, docs/profiles.md, docs/zh/architecture.md
    and docs/blog/2026-10-10-why-nimrtc.{md,zh.md} all listed cloudgame
    as an available Profile — but profiles/cloudgame.json does not exist and
    assembly has no kProfileCloudGame; the registry ships 9 profiles.
    BDFL decided on 2026-11-04 that cloudgame does 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 the teleop family 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
    state cloudgame as 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 — a libSRTP-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 in docs/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 under src/third_party/gmssl, built via
    add_subdirectory when NIMRTC_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 in vendor.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/src was 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 mode 160000) instead of ~2400 checked-in
    files. .gitmodules gains the real entry
    (https://github.com/cisco/libsrtp.git, branch main), the nested
    clone's git dir was absorbed into .git/modules/, and vendor.json
    records the conversion (upstream_version corrected from master to
    main, notes rewritten). tools/check_vendor.py now reports
    libsrtp as ok — 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, ctest 629/629 passed, test_srtp_test 8/8 passed.

  • The vendor manifest now tells the truth about what is a submodule.
    tools/check_vendor.py distinguishes a registered submodule (a
    gitlink, index mode 160000) from a vendor whose sources are still
    checked into this repository; the latter is now reported as
    vendored-tree instead of being counted as a verified submodule.
    .gitmodules no longer lists libjuice and mbedtls, which have no
    gitlink in the index (their intended settings are kept as comments,
    with the blocker for each conversion spelled out).
    vendor.json records the state and the local deltas per vendor, and
    src/third_party/SOURCE_VERSIONS — which claimed to be copied
    verbatim from vendor.json but was not — is corrected: libopus now
    points at 22244de, googletest at the v1.12.0 revision upstream
    actually tags, and msquic is 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.py is 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.sh is the Linux path: the same
      tiers driven by a real tc qdisc netem qdisc attached to lo
      inside a throwaway network namespace (so the host's loopback is
      never reshaped). The tool's --mode netem then 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 on time.monotonic(), which on
      Windows is GetTickCount64 with 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 with Condition.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 in build/e2e/bench_weaknet_netem.json
      next to the portable build/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 new VideoReceiver::set_feedback_callback() (plain
      data: the lost sequence numbers, plus a key-frame request when
      picture data was lost) — ReceiverStats:: keyframe_requests_emitted counts 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, and plugins::VideoReceiverStats /
      VideoSenderStats expose 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, so protect_rtcp() and not protect_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 its recv().
    • The new tests/test_video_feedback_loop.cpp covers the closed loop
      end to end (loss → NACK → retransmission → re-delivery, and PLI →
      key frame).
    • The new tests/test_engine_video_feedback.cpp covers 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's force_keyframe(), and that an
      unrelated RTCP packet (a Receiver Report) is left alone.
  • 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_strategy module; 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 through video_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_playout and
      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.
  • The Goog-CC bandwidth estimator landed alongside AIMD (v1.1 Track
    Q1, "BWE 主线升级").
    src/modules/bwe/ gains GoogCcBwe, a
    delay-plus-loss hybrid estimator registered under the factory id
    "goog-cc"; AIMD stays the default backend, and
    EngineConfig::bwe_name opts 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, and tests/test_bwe.cpp covers 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 引擎级暴露 / 命令-画面关联").

    NimRTCEngine exposes the bidirectional mapping as additive
    NIMRTC_API_UNSTABLE methods — record_video_ref_frame() mounts a
    frame id, ref_frame_to_capture_ts() / capture_ts_to_ref_frame()
    resolve it in either direction, and data_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.json in sync; the pinned
    LICENSE text verified Apache-2.0-compatible and recorded in
    vendor.json). NIMRTC_ENABLE_DTLS_GMSSL=ON builds it via
    add_subdirectory with no system-install probing; the default stays
    OFF so the default build is unchanged. CI carries the opt-in
    gmssl-vendored / msvc legs running test_dtls_gmssl_tlcp.

  • The SRTP backend seam landed; SM4-GCM stays v1.2+ (v1.1 Track X2).
    src/plugins/include/nimrtc/plugins/srtp_backend.hpp declares the
    additive ISrtpSessionBackend + factory seam, and
    src/modules/srtp/ routes the existing libsrtp path through a
    libsrtp_backend adapter — 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 public engine.hpp is untouched (L4).
    Verified 2026-11-05 on Windows/MSVC: full build exit 0, full
    ctest 696/696, freeze scan headers 106 / symbols 707 / missing 0.

  • Track D packaging rules landed (behind NIMRTC_INSTALL=OFF by
    default).
    cmake/NimRTCInstall.cmake (new) centralises the Track D
    install() coverage from one place instead of touching every
    per-module CMakeLists.txt: it installs every src/*/include +
    src/modules/*/include tree to <prefix>/include/, every built
    nimrtc_* STATIC archive (plus opus and nimrtc_vendor_usrsctp,
    which have no upstream install coverage) to <prefix>/lib/, and a
    hand-written NimRTCConfig.cmake + SameMajorVersion version file
    to <prefix>/lib/cmake/NimRTC/. release.yml already passes
    -DNIMRTC_INSTALL=ON on all five configure legs; the top-level
    CMakeLists.txt only adds the NIMRTC_INSTALL option and
    include(NimRTCInstall). Windows downstream proof verified
    2026-11-03: cmake --install staging holds include/ + lib/ +
    lib/cmake/NimRTC/, and a minimal find_package(NimRTC 1.0 REQUIRED)
    consumer linking nimrtc::engine configures, builds, and runs exit 0
    (Linux downstream proof runs in ci.yml on 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 upstream install()
    rules, so the bundle used to ship without
    libwebrtc-audio-processing-2.a and the abseil archives it
    references: a downstream consumer linking nimrtc::engine failed
    with unresolved webrtc:: / absl:: symbols. The archive set and
    their order now come from the Meson build's own link line, recorded
    by the new tools/apm_link_order.py into
    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.cmake ships
    the archives to <prefix>/lib/webrtc_apm/ together with the order
    manifest, and the installed NimRTCConfig.cmake chains 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 under lib/webrtc_apm/, and a minimal
    find_package(NimRTC 1.0 REQUIRED) consumer linking
    nimrtc::engine links against the real APM and runs exit 0 with
    "real WebRTC APM" initialised (AEC/ANS/AGC).

  • Track A bench CI artifacts (b628fcb). ci.yml windows/msvc and
    linux-gcc legs now run tools/benchmark_latency.py --count 1000 +
    tools/benchmark_dc.py and upload build/e2e/bench_latency.json +
    build/e2e/bench_dc.json as bench-<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.py bursts N UDP datagrams per payload size
    over 127.0.0.1 (256/1200 B datagram plane, 16384 B bidi-stream-chunk
    plane) and emits build/e2e/bench_dc.json with pps + Mbps per size.
    README Benchmarks (EN + ZH) now cites measured transport-floor
    numbers for bench_latency.json + bench_dc.json with 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.md step 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 --markdown reports static lib nimrtc_engine 12.46 MB (<15 MB);
    matches the README static-lib claim. Freeze script
    scripts/check-release-freeze.sh passes 6/6 (additive-only API).

Known limitations (v1.1 C-track, still open)

  • W3 is closed 2026-11-06: the Prebuild WebRTC APM step lost
    continue-on-error on 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) — the v1.0.2 release published the aarch64 bundle, so
    build-linux-aarch64 is a hard gate again (no continue-on-error, back
    in publish-release.needs). docs/plan/ci-workarounds.md W3/W5 remain
    the source of truth.

  • Still open before the v1.1.0 tag: 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 with gpg.format = ssh and 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.md Track 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 tree release/1.1 rather than main (see the "Changed"
    entry on SOAK_REF above): the 2026-11-06 / 2026-11-07 records were
    taken from main, 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 on release/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 prebuild continue-on-error) and W5
    (build-linux-aarch64 soft gate) were closed on 2026-11-06 and
    2026-11-05 respectively; docs/plan/ci-workarounds.md W3/W5 remain the
    source of truth.


Verifying the signature

The public half of the signing key ships with this
release as nimrtc-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 by gpg --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 3A
  • linux-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 3A
  • macos-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 3A
  • windows — 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.