Skip to content

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 publishing time)
Area: Model Compression / Video Coding
Keywords: Learned Video Coding, Cross-Platform Consistency, Entropy Coding, NPU Deployment, DCVC-RT

TL;DR

This work changes the scale parameter required for entropy coding from "computed in real-time by the network" to "deterministically transmitted via hyperprior". This enables neural video codecs to perform "encode on device A, decode on device B" without crashing on heterogeneous NPUs like Apple, Intel, and Qualcomm for the first time. Simultaneously, a series of improvements including gated memory, ReGLU, and long-term reference frame recovery recover the coding efficiency loss caused by cross-platform constraints, achieving a >70% BD-rate(MOS) improvement over 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. Context-oriented coding schemes represented by the DCVC series (such as DCVC-FM and DCVC-RT) can save 60–70% of the bitrate compared to H.265 under equivalent perceptual quality, even exceeding 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 barriers hinder actual deployment. The first is computing power: most neural codec evaluations run on data center GPUs (such as A100), whereas video conferencing practically requires real-time execution on consumer-grade on-device NPUs. The second, more fatal barrier is cross-platform compatibility. Video conferencing inherently requires the encoder and decoder to run on different devices, or even hardware from different vendors. When encoding on an Apple M3 NPU and decoding on an Intel NPU, even with the state-of-the-art DCVC-RT and proper quantization, the output completely disintegrates into noise (snow screen).

The root cause of the problem is that entropy coding requires the encoder and decoder to share an identical probability distribution. In DCVC-RT, this distribution is characterized by the scale parameter \(\boldsymbol{\sigma}\). Even minor, non-deterministic numerical jitters in floating-point computations cause the entropy decoder to select incorrect lookup table indices, decoding erroneous latents. This error propagates and amplifies along the temporal prediction chain, eventually causing a catastrophic collapse. Currently, three industrial approaches are insufficient: integer quantization aims for bit-exact arithmetic, but in real commercial NPUs, many methods use non-standard bit-widths like INT16 which NPU toolchains do not support, leading directly to compilation errors. Even with standard INT8, Apple's Neural Engine (prior to M4) does not run true INT8 but simulates it with FP16. Moreover, different NPU kernels, operator fusion strategies, and rounding modes prevent bit-level consistency. The "calibration message" approach by Tian et al. only reduces the probability of index mismatch without hard guarantees, and fails directly under FP16 precision (where unit roundoff error is about four orders of magnitude larger than FP32), which is necessary for NPUs. The fixed-codebook approach avoids mismatches but lacks competitive compression performance. This paper aims for a deployable codec that is simultaneously highly compressive, sufficiently fast, and truly cross-platform.

The authors' entry point is: rather than hoping all operators can be bit-exact, it is better to ensure that the scale obtained by both sides is identical specifically at the entropy coding step. Since the hyperlatent \(\hat{\mathbf{z}}\) is encoded using a fixed factorized entropy model, it is naturally identical on both sides. Core Idea: Instead of recalculating the scale parameter via the network at the decoder side, it is explicitly derived from the deterministically consistent hyperlatent through "absolute value \(\rightarrow\) spatial/channel expansion \(\rightarrow\) table lookup" and transmitted along with the bitstream. This trades a tolerable bitrate overhead for cross-device entropy coding consistency, which is then compensated for by a suite of architectural and training enhancements.

Method

Overall Architecture

MLVC starts from the floating-point model of DCVC-RT (which achieves SOTA compression with a lightweight and fast design) and modifies its video coding framework. The skeleton of the entire pipeline remains the standard structure of modern learned codecs: the encoder maps the current frame \(x_t\) and temporal context \(F_{t-1}\) to latent \(y_t\). The entropy parameter network then produces the mean \(\mu_t\) and scale \(\sigma_t\). The residual after subtracting the mean is quantized (Q) and entropy-encoded via arithmetic encoding (AE) into the bitstream. The decoder performs arithmetic decoding (AD) to reconstruct \(\hat{y}_t\), adds back \(\mu_t\), restores \(\hat{x}_t\) via the reconstruction network, and updates the next-step temporal context using the state extractor.

All modifications in MLVC revolve around two main lines: first, make it "not crash"; second, "recover the quality." To prevent crashes, the standard entropy model's "network-calculated \(\sigma\)" is replaced with "deterministic derivation of \(\sigma\) from the hyperlatent" (scale sending), combined with long-term reference frame recovery, hardware-compatible activation, and periodic I-frames to suppress floating-point drift. To recover quality, gated memory is used to enhance the decoder's long-term modeling, ReGLU is employed to boost representational capacity under the constraint of 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 & Expressiveness"]
    D -->|"I-Frame Dropout during Training<br/>Unified I/P Model"| E["Entropy Coding → Bitstream → Cross-Platform Decoding"]
    E -->|"Long-Chain Divergence Control"| F["LTR Recovery + Periodic I-Frame"]
    F --> G["Reconstructed Frame x̂_t (Optimized with Perceptual/ROI Loss)"]

Key Designs

1. Scale Sending: Shifting the Scale Parameter from "Real-time Computation" to "Deterministic Transmission" to Eliminate Cross-Platform Crashes

This directly addresses the most fatal issue: the entropy model scales calculated on both sides mismatch, causing decoding crashes. The most straightforward solution is to completely abandon any adaptive prior (the 0-prior row in Table 1). While this prevents crashes, the BD-rate deteriorates from -69.6% to +20.5%, which is unacceptable. The other extreme is to explicitly transmit all scales. However, 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, leading to prohibitive overhead. The proposed MLVC utilizes the strong spatial and cross-channel correlation of scale parameters to perform structured parameter sharing, compressing the parameter count by approximately \(s^2\cdot r\) times (typically 128\(\times\)), and then encodes the remaining few 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 obtained through three deterministic expansion steps, followed by a table lookup. First, the absolute value is taken as \(\boldsymbol{I}^{\text{base}}=|\hat{\mathbf{z}}_{1:C_y/r}|\) (to ensure non-negative indices). Then, according to the spatial expansion factor \(s=H_y/H_z\) and the channel duplication factor \(r\), each hyperlatent coordinate is mapped to an \(s\times s\) spatial block, and each channel is copied \(r\) times: \(\boldsymbol{I}_{c,h,w}=\boldsymbol{I}^{\text{base}}_{\lfloor c/r\rfloor,\lfloor h/s\rfloor,\lfloor w/s\rfloor}\). Finally, the quantized scale is retrieved from a fixed codebook: \(\boldsymbol{\sigma}_{c,h,w}=\operatorname{lookup}(\boldsymbol{I}_{c,h,w})\). Crucially, since \(\hat{\mathbf{z}}\) is encoded using a fixed factorized entropy model, it is guaranteed to be bit-consistent on both sides, ensuring that the derived \(\sigma\) is identical—rooting out crashes without requiring any bit-exact arithmetic. This design also accelerates decoding: \(\sigma\) is prepared before decoding any latent groups, allowing all groups to be decoded in a single arithmetic decoding pass instead of interleaving "decode one 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}\)) because mean mismatches do not cause catastrophic decoding failure.

2. Long-Term Reference Frame Recovery (LTR): Shortening the Prediction Chain to Suppress Drift Without Relying on Expensive I-Frames

Scale sending resolves the entropy decoding crash, but floating-point disparities still cause gradual drift in features and reconstructed frames. The encoder and decoder each maintain recursively updated feature buffers, and minor, per-frame differences accumulate along the long prediction chain, growing unboundedly without synchronization. The most direct suppression method is to use a very short I-frame period (e.g., 64 frames) to shorten the chain length, but I-frames are computationally and rate-distortionally expensive. The authors borrow the concept of long-term reference 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 an I-period of 12 generates a maximum prediction chain of 12 frames, whereas using an LTR with a period of 4 (starting from frame 1) reduces the maximum chain length to 7 frames, naturally enhancing robustness to packet loss. The key highlight is a counterintuitive conclusion: on a single platform under a fixed I-frame period, LTR strictly degrades the BD-rate due to the introduction of redundancy; however, in cross-platform scenarios, it shortens the prediction chain, avoids quality collapse from reference divergence, and actually improves compression efficiency. Table 11 confirms this: under the Apple GPU \(\rightarrow\) NPU pair (which has the largest divergence), LTR allows the IP period to extend to 256 while keeping Delta at only -1.0, achieving better BD-rate at equivalent divergence levels via longer I-frame periods.

3. Hardware-Compatible Activation + ReGLU: Recovering Expressiveness Under the Constraint of Simple Activations

Many NPUs use piecewise approximations rather than precise calculations for non-linear activations. These proprietary implementations differ, and minor discrepancies accumulate layer-by-layer in deep networks to cause cross-platform divergence. Complex activations like WSiLU also frequently lack optimized kernels, slow down inference. The authors scanned common activations supported by the Apple Neural Engine and found that only ReLU and LeakyReLU exhibit zero error relative to the ground truth. Consequently, they restricted the architecture to these two. However, simpler activations incur a BD-rate penalty. To recover expressiveness, the authors employ gating mechanisms relying only 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)\) clips the activation to 1 to prevent large activations amplified by the multiplicative gating from destabilizing training. It only replaces channel addition with multiplicative gating in DCVC-RT's deep convolutional blocks, while LeakyReLU is retained elsewhere. In Table 10, ReGLU achieves a BD-rate of -56.6%, approaching the non-deployable WSiLU (-57.5%) without increasing codec divergence. Table 9 shows that gating introduces virtually zero extra execution overhead.

4. Gated Memory: Equipping the Recursive Decoder with "Long-term Memory" and Unifying I/P Models via I-Frame Dropout

DCVC-RT uses the features themselves as temporal states, where long-term information capacity is limited, resulting in degraded reconstruction of occluded objects and poor 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 outputs \(\mathbf{f}_{in}=\text{Decoder}(\hat{\mathbf{y}}_t,\mathbf{F}_{t-1})\), split 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 use standard sigmoid/tanh or be replaced with ReLU piecewise approximations for hardware compatibility. The cost is marginal: compared to the baseline, it only triples the output channels of the final \(1\times1\) convolution while keeping the total recurrent state size constant (replacing the 256-dimensional reference feature with a 128-dimensional reference feature + 128-dimensional memory), causing almost no drop in FPS.

Hand-in-hand with memory is the unified I/P model and I-frame dropout: most learned codecs maintain separate models for I and P frames (for DCVC-RT, the I and P models are 174MB and 79MB in FP32 respectively), doubling storage and deployment overhead. MLVC defines an I-frame as a "P-frame whose reference 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), teaching the single model to encode without temporal dependencies. Shorter I-frame period configurations benefit more, as they encounter I-frame conditions more frequently during inference. Additionally, periodic I-frames serve as a fallback: despite LTR and simple activations, floating-point limitations still cause feature buffers to diverge over long sequences, necessitating periodic I-frames to fully re-synchronize states on both sides (which is a distinction from traditional codecs, as traditional codecs do not rely on periodic I-frames to remain cross-platform compatible).

Loss & Training

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

For the perceptual model, the first stage uses standard PSNR loss, switching to perceptual loss during fine-tuning. The loss consists of two parts: LPIPS to enhance texture fidelity, enhanced by a region-of-interest (ROI) mask for pixel weighting. The ROI mask is derived during training using a face segmentation model (RetinaFace/FaRL). 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})}\). Deriving the mask weights yields \(w_{ROI}=\frac{k}{p(1+k)},\,w_{BG}=\frac{1}{(1-p)(1+k)}\), which satisfies the dual constraints of "maintaining the total loss magnitude" and "rendering the contribution of ROI pixels \(k\) times that of background pixels" (\(p\) is the probability of a pixel belonging to the ROI in the dataset). The authors deliberately do not use the mask to modulate latents, as done in some prior works, avoiding any reliance 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, unified 720p display). Objective evaluation is performed on HEVC B-E. 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 key lies in the "Cross-Platform" column: DCVC-RT indeed yields better subjective quality, but it is entirely unable to decode on heterogeneous hardware (cross-platform BD-rate is denoted as \(\infty\)). The MLVC perceptual model achieves a -75.5% BD-rate(MOS) relative to hardware HEVC, a result that becomes meaningful only when coupled with the cross-platform capability. The authors also perform a fair comparison: fine-tuning DCVC-RT with the same ROI and perceptual losses pushes it 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 cost-effective for enabling cross-device decoding.

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; proves adaptive priors cannot be naively abandoned
+ Scale Sending (WSiLU) −54.5 −56.1 101.8 Still poor cross-platform performance (activation divergence)
+ Hardware-compatible Activation (LReLU) −49.2 −53.5 6.7 XP goes from 101.8 \(\to\) 6.7; activation is the primary cause of divergence
+ Gated Memory −52.1 −58.4 −21.9 Memory simultaneously improves 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 continues to drop
+ LTR (IP=1024, Full MLVC) −52.0 −60.2 −58.7 LTR supports ultra-long I-frame periods
MLVC-S (Small Model) −36.5 −48.6 −47.3 Still achieves −37% at 1080p@30FPS

Key Findings

  • Activation functions are the leading culprit for cross-platform divergence: just adding scale sending leaves the TH(XP) at a poor 101.8% (worse than the anchor), but replacing it with LeakyReLU dramatically drops it to 6.7%. Numerical divergence primarily stems from the piecewise approximation of complex activations on NPUs (the supplementary material detects obvious piecewise approximation for SiLU on Apple NPUs, while ReLU/LeakyReLU exhibit zero error).
  • Full MLVC drops about 18 percentage points in same-platform BD-rate compared to the original DCVC-RT (-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 trades "completely unusable cross-platform (\(\infty\))" for "cross-platform -58.7%".
  • The value of LTR in cross-platform setups is counterintuitive: although LTR drags down the BD-rate on a single platform due to redundancy, it prevents reference divergence from collapsing in cross-platform scenarios by shortening the prediction chain. This allows the I-frame period to stretch from 64 to 1024, improving compression efficiency and bolstering packet-loss resilience.
  • Speed target met across all boards: the average encoding/decoding frame rates for 360p across three platforms (Apple, Intel, Qualcomm NPUs) reach 103/99 FPS. Both MLVC and MLVC-S achieve real-time status at 720p across all platforms (>30 FPS), and MLVC-S can even process 1080p at 30 FPS on Apple M3 Pro. In the cross-platform BD-rate matrix of Fig. 6(b), the discrepancies between most codec pairs remain within 2 percentage points, with absolutely no crashes.

Highlights & Insights

  • The paradigm of "ensuring consistency only where consistency is strictly required" is extremely practical: instead of striving for bit-exactness across the entire network (which is practically impossible on heterogeneous NPUs), the design focuses precisely on ensuring the entropy coding scale matches on both ends, transmitting it via the naturally consistent hyperlatent. This strategic shift—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 empirical evidence of cross-platform numerical divergence in the supplementary material is highly compelling: the authors test a basic, 128-channel pointwise convolution and find that INT8 quantization diverges under nearly all combinations of device-runtime environments (Tables 12–15). They trace this layer-by-layer to discrepancies in NPU implementations of multiplication and rounding which deviate from the IEEE 754 default rounding mode. This reveals precisely why integer quantization fails to resolve cross-platform compatibility on commercial NPUs, forming one of the most powerful and insightful parts of the paper.
  • Redefining the I-frame as a "gray-referenced P-frame" combined with I-frame dropout is an elegant engineering simplification: one model replaces two, saving half the storage. Using probabilistic replacement during training allows a single model to learn both modes. Moreover, it naturally handles scenarios with severe prediction mismatch upon scene cuts (Supplementary 0.B.8 reveals only a 2% drop with stale LTR under scene cuts).
  • Honest quantification of the "cost of cross-platform capability": the authors do not shy away from the performance gap between MLVC and DCVC-RT. Instead, they conduct controlled comparisons to pin down this gap to about 6 percentage points (subjectively) and 18 percentage points (objective PSNR on the same platform), arguing that this cost is a worthwhile trade-off for the qualitative transition of whether deployment is feasible.

Limitations & Future Work

  • Cross-platform constraints incur a tangible rate-distortion cost: the same-platform PSNR-BD-rate is about 18 percentage points lower than DCVC-RT. While the authors narrow the subjective gap to about 6 percentage points using perceptual/ROI training, the gap in objective PSNR remains structural, stemming from the abandonment of the "same-platform bit-exactness" assumption.
  • Heavy reliance on FP16 instead of integer determinism: this work explicitly operates on FP16 inference (given its wide commercial NPU support). The flip side is the necessity of periodic I-frames to mitigate floating-point drift. This differs from traditional codecs, which do not query periodic I-frames to maintain cross-platform behavior, making this an "engineer-deployable but not fully resolved" trade-off. The authors acknowledge that if NPU vendors standardize IEEE 754 rounding and operator sequencing in the future, the integer route remains a more thorough solution.
  • Perceptual optimization is centered on face ROI, indicating scene-specific specialization: the ROI mask is derived via face segmentation, yielding significant benefits for video conferencing (which is face-heavy). However, transferring this to screen-sharing (which depends on text clarity) requires a different ROI strategy; thus, generalization is bound to the chosen perceptual prior.
  • Future directions pointed out by the authors: power consumption is the next optimization frontier after meeting real-time latency demands; simultaneous encoding and decoding at high resolutions (1080p+) on a single device under a symmetric architecture remains challenging.
  • vs DCVC-RT: DCVC-RT serves as the baseline and upper bound of this work, delivering superior compression and speed. However, because it calculates the scale parameter using networks in real-time, its entropy decoding inevitably collapses on heterogeneous NPUs. Its "cross-platform" testing was previously limited to NVIDIA GPUs (single vendor, not true cross-platform). MLVC sacrifices some rate-distortion performance to gain authentic multi-vendor NPU deployment capability.
  • vs Calibration Message (Tian et al. 2023): They transmit calibration side information to reduce index mismatch probability. However, this is only a probabilistic mitigation rather than a hard guarantee, and was validated only on a single 96-frame UVG video under FP32. This work's replication shows that once switched to FP16 (which is necessary for NPUs and has a unit roundoff error four orders of magnitude larger), the calibration fails entirely. MLVC's scale sending provides a deterministic hard guarantee.
  • vs Fixed Codebook (Tian et al. 2024, "Effortless"): They transmit discrete codebook indices and eliminate entropy modeling altogether to circumvent mismatches, but their compression performance is uncompetitive and evaluated under unfair GOP settings (their GOP=32 vs H.264/265 regular GOP=12). When normalized to the unified anchor in the supplementary material, MLVC reaches -45.2% on HEVC-B, significantly outperforming their +15.0%.
  • vs MobileCodec / MobileNVC: This mobile track centers on edge computing power (redesigning motion compensation to bypass expensive warping). However, MobileNVC did not perform any cross-platform testing, and its BD-rate becomes positive (underperforming hardware HEVC) when converted to this paper's anchor. MLVC succeeds in being both "cross-platform viable" and "superior to hardware HEVC" simultaneously.

Rating

  • Novelty: ⭐⭐⭐⭐ The core idea of "deterministic scale transmission" is simple, effective, and hits the pain points of actual deployment. However, individual components (memory, ReGLU, LTR) are mostly clever combinations and engineering implementations of existing concepts.
  • Experimental Thoroughness: ⭐⭐⭐⭐⭐ Extremely persuasive with on-device speed tests across three platforms, subjective and objective BD-rate evaluations, and a highly detailed empirical analysis of cross-platform numerical divergence (explaining issues across INT8, FP16, and IEEE 754).
  • Writing Quality: ⭐⭐⭐⭐ Clear analysis of motivation and prior failed attempts, alongside honest quantification of deployment costs. Symbol-heavy portions (such as scale expansion and ROI weight derivations) have a slight barrier of entry for readers.
  • Value: ⭐⭐⭐⭐⭐ This is the first neural video codec truly deployable on heterogeneous consumer-grade NPUs, directly bridging the chasm where academic SOTA solutions could not enter production systems. It holds high industrial deployment value.