MLVC: Multi-Platform Learned Video Codec for Real-World Deployment¶

Conference: ECCV 2026
arXiv: 2606.28027
Code: The paper states "Code will be released" (not released at the time of publication)
Area: Model Compression / Video Coding
Keywords: Learned Video Coding, Cross-Platform Consistency, Entropy Coding, NPU Deployment, DCVC-RT

TL;DR¶

By changing the scale parameters required for entropy coding from "computed in real-time by the network" to "deterministically transmitted through the hyperprior," this work enables neural video codecs to perform "encode on A, decode on B" across heterogeneous NPUs (such as Apple, Intel, and Qualcomm) for the first time without crashing. Concurrently, a series of improvements including gated memory, ReGLU, and long-term reference frame recovery are introduced to recoup the rate-distortion loss caused by cross-platform constraints, achieving a >70% BD-rate (MOS) reduction relative to hardware HEVC on video conferencing benchmarks, with an average of 100 FPS across three platforms.

Background & Motivation¶

In recent years, neural video compression has matured to the point where learned codecs consistently outperform traditional standards in rate-distortion performance. Contextual coding schemes represented by the DCVC series (e.g., DCVC-FM, DCVC-RT) can save 60–70% of the bitrate compared to H.265 under equivalent perceptual quality, and even surpass the latest ECM reference software. Paradoxically, however, not a single neural codec is utilized in real production systems like Zoom, Teams, or WebRTC. Two major hurdles block deployment. The first is computational cost—most neural codec evaluations run on data center GPUs (such as A100), whereas video conferencing in practice requires real-time execution on consumer-level on-device NPUs. The second, more fatal hurdle is cross-platform compatibility. Video conferencing naturally demands that the encoder and decoder run on different devices or even hardware from different vendors. When encoding on an Apple M3 NPU and decoding on an Intel NPU, even SOTA methods like DCVC-RT will see their output completely degrade into static, even with quantization applied.

The root of the problem lies in the requirement that both the encoder and decoder use the identical probability distribution for entropy coding, which is characterized by the scale parameter \(\boldsymbol{\sigma}\) in DCVC-RT. Even a tiny non-deterministic numerical fluctuation in floating-point computation will cause the entropy decoder to select different lookup table indices, decoding incorrect latents. This error then propagates and amplifies along the temporal prediction chain, eventually leading to a complete collapse. The industry's current three coping strategies are insufficiently robust: integer quantization aims for bit-exact arithmetic to cure this fundamentally, but the reality of commercial NPUs is that many tools do not support non-standard bit widths like INT16, resulting in compilation failures. Even with standard INT8, Apple's NE prior to M4 did not run true INT8 but instead used FP16 simulation. Moreover, kernel selection, operator fusion, and rounding modes vary across NPU vendors, preventing bit-level consistency. The "calibration information" approach by Tian et al. only reduces the probability of index mismatch without giving hard guarantees and directly fails under the FP16 precision required by NPUs (where the unit roundoff error is about four orders of magnitude larger than FP32). While the fixed codebook route avoids mismatch, it fails to deliver competitive compression performance. This paper aims for a deployable codec that simultaneously satisfies high compression efficiency, real-time speed, and true cross-platform compatibility.

The authors' entry point is that rather than hoping for bit-exactness across all operators, it is more practical to ensure that "both ends obtain the exact same scale" only at the entropy coding step—whereas the hyperlatent \(\hat{\mathbf{z}}\), encoded via a non-parametric factorized entropy model, is naturally identical at both ends. Core Idea: Instead of recalculating the scale parameter via the network at the decoder side, it is explicitly derived from the deterministically consistent hyperlatent via "absolute value \(\rightarrow\) spatial/channel expansion \(\rightarrow\) lookup table" and transmitted along with the bitstream. This trade-off accepts a manageable bitrate overhead to secure cross-device consistency for entropy coding, while a suite of architectural and training enhancements is proposed to compensate for this overhead.

Method¶

Overall Architecture¶

MLVC starts with the floating-point model of DCVC-RT (which represents SOTA compression and is lightweight and fast) and adapts its video coding framework. The skeleton of the overall pipeline retains the standard structure of modern learned codecs: the encoder maps the current frame \(x_t\) and the temporal context \(F_{t-1}\) to the latent \(y_t\). The entropy parameter network then generates the mean \(\mu_t\) and scale \(\sigma_t\). The residual after subtracting the mean is quantized (Q) and arithmetically encoded (AE) into the bitstream. The decoder arithmetically decodes (AD) to recover \(\hat{y}_t\), adds back \(\mu_t\), and reconstructs \(\hat{x}_t\) via the reconstruction network, followed by updating the temporal context for the next step using a state extractor.

All modifications in MLVC revolve around two main objectives: first, make it "not crash", and second, "recover the quality". To avoid crashing, the standard entropy model's online calculation of \(\sigma\) by the network is replaced with a deterministic derivation of \(\sigma\) from the hyperlatent (scale sending), combined with long-term reference frame recovery, hardware-compatible activations, and periodic I-frames to suppress floating-point drift. To recover quality, gated memory is employed to enhance the decoder's long-term modeling, ReGLU is used to boost representational capacity under the constraint of using only simple activations, I-frame dropout is applied to enable a single model to handle both I and P frames, and perceptual plus ROI losses are used to align subjective quality.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Current Frame x_t + Temporal Context F_t-1"] --> B["Scale Sending<br/>Deterministic derivation of σ from hyperlatent"]
    B --> C["Hardware-Compatible Activation<br/>Only ReLU/LeakyReLU"]
    C --> D["Gated Memory + ReGLU<br/>Recover long-term modeling & capacity"]
    D -->|"Training-time I-frame dropout<br/>Unified I/P model"| E["Entropy Coding → Bitstream → Cross-Platform Decoding"]
    E -->|"Long-chain drift control"| F["LTR Recovery + Periodic I-frame"]
    F --> G["Reconstructed Frame x̂_t (Optimized by Perceptual/ROI loss)"]

Key Designs¶

1. Scale Sending: Replacing "Real-time Computation" of Scales with "Deterministic Transmission" to Eradicate Cross-Platform Collapse

This directly targets the most critical pain point—the decoding failure caused by inconsistent scale parameters calculated at the encoder and decoder. The most brute-force solution is to discard adaptive priors entirely (the 0-prior row in Table 1); while this indeed prevents crashing, the BD-rate deteriorates from -69.6% directly to +20.5%, which is unacceptable. The other extreme is to transmit all scale parameters explicitly, but the scale tensor has a size of \(\frac{H}{16}\times\frac{W}{16}\times C_y\), which is almost as large as the encoded frame itself, incurring prohibitive overhead. MLVC resolves this by leveraging the strong spatial and cross-channel correlation of scale parameters to perform structured parameter sharing, reducing the parameter size by a factor of \(s^2\cdot r\) (typically 128\(\times\)), and encoding the remaining small portion of parameters into the hyperlatent representation for transmission.

Specifically, starting from the quantized hyperlatent \(\hat{\mathbf{z}}\in\mathbb{Z}^{C_z\times H_z\times W_z}\), the scale index is deterministically expanded in three steps and then looked up: first, the absolute value is taken as \(\boldsymbol{I}^{\text{base}}=|\hat{\mathbf{z}}_{1:C_y/r}|\) (ensuring non-negative indices). Then, according to the spatial expansion factor \(s=H_y/H_z\) and channel repetition factor \(r\), each hyperlatent location is mapped to a spatial block of size \(s\times s\), and each channel is replicated \(r\) times: \(\boldsymbol{I}_{c,h,w}=\boldsymbol{I}^{\text{base}}_{\lfloor c/r\rfloor,\lfloor h/s\rfloor,\lfloor w/s\rfloor}\). Finally, \(\boldsymbol{\sigma}_{c,h,w}=\operatorname{lookup}(\boldsymbol{I}_{c,h,w})\) retrieves the quantized scale from a pre-defined codebook. Crucially, because \(\hat{\mathbf{z}}\) is encoded using a fixed factorized entropy model, its representation is guaranteed to be bit-consistent across devices, thereby ensuring that the derived \(\sigma\) is inherently identical—eliminating decoding collapse without requiring any bit-exact arithmetic. This design also accelerates decoding: because \(\sigma\) is fully prepared before decoding any latent group, all groups can be arithmetically decoded in a single pass, in contrast to the standard approach of interleaving "decode group \(\rightarrow\) run network \(\rightarrow\) decode next group". The mean \(\mu\) still retains autoregressive modeling (prior fusion yields \(\mu_{t,1}\), and spatial prior based on decoded \(\hat{y}_{t,1}\) yields \(\mu_{t,2}\)), as a mismatch in the mean does not trigger decoding collapse.

2. Long-Term Reference (LTR) Frame Recovery: Shortening Prediction Chains to Suppress Drift Without Expensive I-frames

While scale sending resolves entropy decoding collapse, floating-point differences still cause progressive drift in features and reconstructed frames. Since the encoder and decoder maintain recursively updated temporal feature buffers, small errors at each frame accumulate along the long prediction chain, growing boundlessly without synchronization. The most straightforward suppression technique is using a very short I-frame period (e.g., 64 frames) to shorten the chain, but I-frames are costly and impair rate-distortion performance. The authors borrow long-term reference (LTR) frame recovery from traditional codecs: instead of relying solely on I-frames, active LTR recovery frames are periodically inserted to manage the prediction chain. The intuition in Fig. 5(b) is that while an I-frame period of 12 would result in a maximum prediction chain length of 12 frames, using an LTR with a period of 4 (starting from frame 1) reduces the maximum chain length to 7 frames and naturally enhances robustness to packet loss. Crucially, a counter-intuitive conclusion is drawn: under a single-platform setting with a fixed I-frame period, LTR strictly degrades BD-rate due to the introduction of redundancy; however, in cross-platform scenarios, by shortening the prediction chain and preventing quality collapse from reference divergence, it actually improves compression efficiency. Table 11 confirms this—under the Apple GPU \(\rightarrow\) NPU pair, which exhibits the worst divergence, LTR allows the IP period to be extended to 256 with a Delta of only -1.0, achieving a better BD-rate at a comparable divergence level compared to using a longer I-frame period.

3. Hardware-Compatible Activation + ReGLU: Clamping Back Representation Under the Constraint of Simple Activations

Many NPUs implement non-linear activations using piecewise approximations rather than exact calculations. These vendor-specific differences are non-standardized and accumulate layer-by-layer in deep networks, causing cross-platform divergence. Furthermore, complex activations like WSiLU often lack optimized kernels and slow down inference. The authors profiled common activations supported by the Apple Neural Engine and discovered that only ReLU and LeakyReLU exhibit zero error relative to the ground truth. Consequently, they constrained the network architecture to use only these two activations. However, simple activations incur a BD-rate penalty. To recover representation capacity, the authors employ gating that relies solely on cross-platform compatible operators: ReGLU is defined as \(\text{ReGLU}(\mathbf{x})=\mathbf{x}_{:C/2}\odot\text{ReLU1}(\mathbf{x}_{C/2:})\), where \(\text{ReLU1}(\cdot)=\min(\text{ReLU}(\cdot),1)\) clamps the activation to 1 to prevent multiplicative gating from amplifying large activations and disrupting training stability. ReGLU only replaces the channel addition in the deep convolutional blocks of DCVC-RT with multiplicative gating, while LeakyReLU is used elsewhere. As shown in Table 10, ReGLU achieves a -56.6% BD-rate, close to that of the non-deployable WSiLU (-57.5%), without increasing cross-platform divergence; Table 9 shows that gating introduces virtually zero runtime overhead.

4. Gated Memory: Supplementing Recursive Decoders with Long-Term Memory, and Unifying I/P Models with I-frame Dropout

DCVC-RT uses the feature itself as the temporal state, which has limited capacity for long-term information, leading to degraded reconstruction of occluded objects and cross-frame consistency. MLVC borrows the gated recurrent structure (LSTM) to add an explicit long-term memory state \(\mathbf{m}_t\) to the decoder. The decoder first produces \(\mathbf{f}_{in}=\text{Decoder}(\hat{\mathbf{y}}_t,\mathbf{F}_{t-1})\), which is sliced into three parts \([\mathbf{s}_t,\mathbf{g}_f,\mathbf{g}_o]\). The forget gate updates the memory \(\mathbf{m}_t=\sigma(\mathbf{g}_f)\odot\mathbf{m}_{t-1}+(1-\sigma(\mathbf{g}_f))\odot\tau(\mathbf{s}_t)\), and the output gate produces \(\mathbf{f}_{out}=\sigma(\mathbf{g}_o)\odot\tau(\mathbf{m}_t)\cdot\mathbf{q}_{dec}\). The gate/memory activations \(\sigma,\tau\) can either be standard sigmoid/tanh or replaced with ReLU piecewise approximations to accommodate hardware. The overhead is negligible—compared to the baseline, it only triples the output channels of the final \(1\times1\) convolution while maintaining the same total recurrent state size (replacing a 256-dimensional reference feature with a 128-dimensional reference feature + 128-dimensional memory), causing almost no drop in FPS.

Accompanying the memory are a unified I/P model and I-frame dropout: most learned codecs maintain separate models for I and P frames (under FP32, DCVC-RT's I and P models are 174MB and 79MB, respectively), doubling storage and deployment costs. MLVC redefines an I-frame as a P-frame whose reference frame is a uniform gray frame (0.5 in YUV space), thereby requiring only a single model. During training, true I-frames are replaced with gray frames with a probability of \(p=0.5\) (I-frame dropout) so that the single model learns to encode without temporal dependency. Configurations with shorter I-frame periods benefit more, as they encounter the I-frame condition more frequently during inference. Additionally, periodic I-frames serve as a fallback; even with LTR and simple activations, the limits of floating-point precision still cause feature buffer divergence over long sequences. Periodic I-frames are thus used to completely resynchronize states at both ends (which is a key difference from traditional codecs, which do not rely on periodic I-frames to maintain cross-platform alignment).

Loss & Training¶

Training follows the schedule of DCVC-RT: the Vimeo-90K septuplet dataset is used for the first stage, followed by fine-tuning on long sequences up to 64 frames. Long-sequence training employs gradient and frame-gradient clipping to maintain stability, and gradient checkpointing is used during fine-tuning to save memory. Bitrate control and YUV color space training match DCVC-RT. Training a 32-frame sequence on 8 V100 GPUs takes approximately 5 days.

For the perceptual model, the first stage uses standard PSNR loss, while the fine-tuning stage switches to perceptual loss. The loss consists of two parts: LPIPS to enhance texture fidelity, and an ROI mask to weight pixels. An face detection/segmentation model (RetinaFace/FaRL) is used during training to export ROI masks. The total loss is formulated as \(L=w_m\cdot\overline{M\otimes\text{MSE}(x,\hat{x})}+w_l\cdot\overline{M\otimes\text{LPIPS}(x,\hat{x})}\). The mask weights \(w_{ROI}=\frac{k}{p(1+k)}\) and \(w_{BG}=\frac{1}{(1-p)(1+k)}\) are derived to satisfy two constraints: maintaining the same overall loss magnitude and ensuring that ROI pixels contribute \(k\) times more than the background (\(p\) is the probability of a pixel belonging to the ROI in the dataset). Notably, the authors do not use the mask to modulate latents as in some prior works, thus avoiding dependency on an external segmentation model during deployment; they also do not use GAN loss, as it tends to cause temporal flickering and identity distortion.

Key Experimental Results¶

Main Results¶

Subjective evaluation is performed on the video conferencing dataset VCD using ITU-T P.910 (5-point ACR, 15 votes per clip, displayed at 720p), while objective evaluation is conducted on HEVC B-E datasets. All BD-rates use the widely deployed hardware encoder Intel Quick Sync HEVC-QSV as the sole anchor.

Codec	Cross-Platform	BD-360(MOS)	BD-540(MOS)	FPS(360/540, Apple M3 Pro)
HEVC-QSV (anchor)	✓	0.0	0.0	221/170 (Intel Hardware)
DCVC-RT	✗	−76.4	−80.3	102/46
DCVC-RT (perceptual fine-tuned)	✗	−81.9	–	102/46
MLVC (perceptual)	✓	−75.5	−78.8	130/66
MLVC-S (small model)	✓	–	−65.4	300/152
MLVC-multi (bitrate ladder)	✓	−75.5	−65.4	130/152

The critical column is "Cross-Platform": while DCVC-RT indeed delivers superior subjective quality, it completely fails to decode on heterogeneous hardware (its cross-platform BD-rate is denoted as \(\infty\)). The perceptual MLVC model achieves a -75.5% BD-rate (MOS) relative to hardware HEVC, a result that is meaningful primarily due to its cross-platform capability. The authors also conducted a fair comparison: when DCVC-RT is fine-tuned with the same ROI and perceptual losses, its performance improves from -76.4% to -81.9%. This indicates that the net cost of the "cross-platform constraint" is only about 6 percentage points (-81.9% vs -75.5%), which is highly acceptable in exchange for cross-device decodability.

Ablation Study (Table 1, PSNR-BD-rate% vs HEVC-QSV, SP=Same Platform / XP=Cross-Platform)¶

Configuration	Avg(SP)	TH(SP)	TH(XP)	Description
DCVC-RT (original baseline)	−69.6	–	\(\infty\)	Strongest but cross-platform collapse
0-prior (remove adaptive prior)	+20.5	9.6	718.1	No crash but compression collapses, proving naive removal of prior is infeasible
+ Scale Sending (WSiLU)	−54.5	−56.1	101.8	Cross-platform still poor (activation divergence)
+ Hardware-Compatible Activation (LReLU)	−49.2	−53.5	6.7	XP drops from 101.8 to 6.7; activation is the primary source of divergence
+ Gated Memory	−52.1	−58.4	−21.9	Memory simultaneously compensates for SP/XP
+ ReGLU	−56.6	−61.9	−39.8	Gating recovers representation capacity
+ I-frame dropout (IP=64)	−46.1	−46.7	−44.9	Unified I/P, XP further decreases
+ LTR (IP=1024, complete MLVC)	−52.0	−60.2	−58.7	LTR supports ultra-long I-frame periods
MLVC-S (small model)	−36.5	−48.6	−47.3	1080p@30FPS still achieves −37%

Key Findings¶

Activation functions are the leading culprit for cross-platform divergence: when only scale sending is added, TH(XP) is still as high as 101.8% (worse than the anchor), but drops immediately to 6.7% after switching to LeakyReLU. This indicates that numerical divergence primarily stems from the piecewise approximation of complex activations on NPUs (the supplementary material shows that SiLU on Apple NPUs uses piecewise approximation, whereas ReLU/LeakyReLU has zero error).
The complete MLVC loses about 18 percentage points compared to the original DCVC-RT on the same platform (-52% vs -69.6%). This is the direct cost of cross-platform constraints, accumulated from scale sending, hardware-compatible activations, periodic I-frames, and unified I/P models. However, it successfully transforms the codec from "completely unusable cross-platform (\(\infty\))" to "cross-platform -58.7%".
The value of LTR in cross-platform scenarios is counter-intuitive: in a single-platform setting, it degrades the BD-rate due to redundancy. However, in cross-platform scenarios, by shortening the prediction chain, it prevents reference divergence from collapsing quality. This allows the I-frame period to extend from 64 to 1024, which in turn enhances compression efficiency and packet loss robustness.
Speed meets targets across all boards: the average encoding/decoding speed across the three platforms (Apple/Intel/Qualcomm NPUs) is 103/99 FPS at 360p. MLVC achieves real-time speeds (>30 FPS) at 720p across all platforms, and MLVC-S achieves real-time speeds at 720p across all platforms, even reaching 30 FPS at 1080p on Apple M3 Pro. The cross-platform BD-rate matrix in Fig. 6(b) shows that most codec pairs differ by less than 2 percentage points, with zero collapse.

Highlights & Insights¶

The philosophy of "ensuring consistency only where it is strictly required" is highly pragmatic: instead of struggling to achieve bit-exactness across the entire network (which has proven virtually impossible on heterogeneous NPUs), the proposed method precisely targets the one critical place: the entropy coding scale must match on both ends. By utilizing the naturally consistent nature of the hyperlatent, it simply "transmits" this information. This degradation strategy—replacing uncontrollable real-time computation with controllable deterministic derivation—can be generalized to any coding or communication system that relies on synchronized probability models.
The cross-platform numerical divergence evaluation in the supplementary material is highly substantial: the authors demonstrate with a simple 128-channel pointwise convolution that INT8 quantization diverges under almost all combinations of hardware and runtimes (Tables 12–15), attributing this room-by-room to the fact that NPU multiplication and round-off implementations vary and do not follow the IEEE 754 default rounding. This explains deeply why integer quantization cannot salvage cross-platform compatibility on commercial NPUs, presenting one of the most compelling parts of the paper.
Redefining I-frames as "P-frames with a gray reference frame" combined with I-frame dropout is an elegant engineering simplification: it replaces two models with one, saving half the storage. Using probabilistic replacement during training allows the single model to learn both modes naturally while inherently handling the large mismatch when reference frames fail after scene cuts (Supplementary 0.B.8 shows a drop of only 2 points using stale LTRs under scene cuts).
Honestly quantifying the "cost of cross-platform compatibility": the authors do not shy away from the performance gap between MLVC and DCVC-RT. Instead, they perform controlled comparisons to show that this gap is around 6 percentage points (subjective) and 18 percentage points (PSNR on the same platform), arguing that this cost is a worthwhile tradeoff to achieve the qualitative leap of "being deployable".

Limitations & Future Work¶

Cross-platform constraints incur a tangible rate-distortion cost: the PSNR-BD-rate on the same platform is about 18 percentage points lower than DCVC-RT. Although the authors compress the subjective gap to about 6 percentage points through perceptual/ROI training, the gap in objective PSNR remains structural, stemming from abandoning the "same-platform bit-exact" assumption.
Strong reliance on FP16 rather than integer determinism: this work explicitly chooses FP16 inference (due to broad commercial NPU support). The trade-off is the continued necessity of periodic I-frames to mitigate floating-point drift. This differs from traditional codecs, which "do not require periodic I-frames for cross-platform alignment," presenting a compromise that is "engineer-viable but not a fundamental cure." The authors acknowledge that if NPU manufacturers unify IEEE 754 rounding and operator sequencing in the future, the integer route remains a more fundamental solution.
The perceptual optimization is centered on face ROIs, showing clear scene specialization: the ROI mask is derived via face segmentation, which yields high benefits for video conferencing (where faces are heavily emphasized). However, moving to scenarios like screen sharing (where text clarity is critical) requires changing the ROI strategy, meaning generalization is bounded by the chosen perceptual prior.
Future directions noted by the authors: power consumption will be the next frontier of optimization once real-time speed is met; simultaneous encoding and decoding at high resolutions (1080p+) on a single device under symmetric architectures remains challenging.

vs DCVC-RT: DCVC-RT is the starting point of this work and represents the upper bound on the same platform, offering better compression and speed. However, computing scales online via the network inevitably causes entropy decoding collapse on heterogeneous NPUs. It was only verified "cross-platform" within NVIDIA GPUs (single vendor, not true cross-platform). MLVC sacrifices partial rate-distortion performance in exchange for true multi-vendor NPU deployment capability.
vs Calibration Information (Tian et al. 2023): they transmit auxiliary calibration side-information to reduce index mismatch probability. However, this only alleviates the issue probabilistically and provides no hard guarantee, and was only verified on a single 96-frame UVG video under FP32. Re-implementing it in this work revealed that once switched to the NPU-essential FP16 (where unit roundoff error is about four orders of magnitude larger), the calibration fails directly. MLVC's scale sending offers a deterministic, hard guarantee.
vs Fixed Codebook (Tian et al. 2024, "Effortless"): they transmit discrete codebook indices and completely remove entropy modeling to avoid mismatch. However, their compression performance is uncompetitive, under an unfair comparison setting using a GOP of 32 (compared to GOP of 12 for H.264/265). When converted to a unified anchor in the supplementary material, MLVC's -45.2% on HEVC-B is vastly superior to their +15.0%.
vs MobileCodec / MobileNVC: this mobile track focuses on edge computing power (with heavy design on motion compensation to avoid expensive warps), but MobileNVC lacks any cross-platform test and exhibits a positive BD-rate when converted to this work's anchor (failing to outperform hardware HEVC). MLVC simultaneously achieves "cross-platform availability" and "outperforming hardware HEVC".

Rating¶

Novelty: ⭐⭐⭐⭐ The core idea of "deterministically transmitting scales" is elegant and effective, targeting real-world deployment pain points. However, individual components (memory, ReGLU, LTR) are mostly clever combinations and engineering implementations of existing ideas.
Experimental Thoroughness: ⭐⭐⭐⭐⭐ On-device speed tests on three platforms, subjective and objective BD-rate evaluations, and extremely detailed cross-platform numerical divergence profiling (systematically attributing errors to INT8/FP16/IEEE754) provide high credibility.
Writing Quality: ⭐⭐⭐⭐ Motivation and analyses of failed pathways are clear, with an honest quantification of tradeoffs. Symbol-heavy sections (scale expansion, ROI weight derivation) present a slight barrier for readers.
Value: ⭐⭐⭐⭐⭐ The first neural video codec truly deployable on heterogeneous consumer-grade NPUs, bridging the gap between "academic SOTA" and "production systems". It carries high industrial deployment value.