PaperlayerView exact revision on arXiv

Source-linked AI summary

CurveCodec 2: Skeleton-agnostic animation compression with a learned entropy model

Mingyi Shi, Huancheng Lin, Xuelin Chen, Taku Komura

arXiv:2610.04211v1cs.GRcs.AIcs.RO

TL;DR

Skeletal animation stores transforms for many joints even though much motion is implied by the body, and production codecs need to handle arbitrary skeletons with stated error bounds. CurveCodec 2 uses closed-loop curve coding with learned residual probabilities. It requires 0.37× ACL’s bytes at 0.01 cm under the worst-case contract and 0.22× at 0.1 cm under the mean contract.

  • Problem

    Skeletal motion contains redundancy implied by the body, while production codecs must support arbitrary skeletons with stated error bounds; the earlier CurveCodec did not match ACL’s worst case or entropy-code its payload.

    Source: §1 · p. 2

  • Method

    CurveCodec 2 codes sub-tracks as curves with closed-loop quantization and key selection, then entropy-codes prediction residuals under a small learned model.

    Source: §1 · p. 2

  • Results

    CurveCodec 2 uses 0.37× ACL’s bytes at 0.01 cm under the worst-case contract and 0.22× at 0.1 cm under either contract.

    Source: §1 · p. 2

  • Takeaways & Limitations

    One model serves every rig tested, including a species absent from training, without retraining.

    Source: §8 · p. 13

    CurveCodec 2 decodes whole clips sequentially, so it cannot provide ACL’s constant-time pose access and is intended for load-time storage or distribution.

    Source: §7 · p. 12

Abstract

from arXiv · show

Skeletal motion is stored as every joint's transform at every frame, yet most of it is implied by the body rather than by what the motion is about. Compression is one way to ask what a motion must still say once the body is known, and a production codec must answer it for any skeleton with a stated error bound. Our earlier codec, CurveCodec, matched the mean error of ACL, the production library of modern game engines, with a learned prior over sparse anchors, but not ACL's worst case, and it counted its payload as floats rather than bits. Here we ask where the redundancy of skeletal motion lies and which part of a codec a learned model should take over. Measurements give three answers. At production precision the largest saving comes from predicting each quantized curve from its own past, the second from choosing per joint, in closed loop through the hierarchy, which samples not to code. On the gaps such an encoder leaves, a nearest-neighbour oracle over millions of training samples is no better than linear interpolation, and no learned in-betweener we tried paid for itself. What a network does learn is the distribution of the residuals the codec must send. CurveCodec 2 codes every sub-track as a curve in the log map, quantized in closed loop and thinned to rate-distortion-selected keys, with residuals entropy-coded under a small learned model whose integer inference is bit-exact across platforms. Two contracts are verified on every decoded clip: ACL's own worst case per joint within a stated tolerance, or ACL's mean error per clip. On a held-out test side of 4,472 clips from 33 datasets, CurveCodec 2 needs 0.37x ACL's bytes at ACL's default precision of 0.01 cm under the worst-case contract and 0.22x at 0.1 cm under the mean contract, decodes on one CPU core, and transfers without retraining to a species absent from training. Project page: https://rubbly.cn/publications/curvecodec/

1 Introduction

The paper measures where skeletal-motion redundancy remains under production error contracts, then uses those findings to place learning in residual entropy coding. CurveCodec 2 combines that design with closed-loop quantization and key selection.

1 Introduction

  • ACL’s fast production codec neither models time nor symbol statistics, while learned motion encoders couple their latent priors to training skeletons and domains and miss production precision.The earlier CurveCodec matched ACL’s mean error but exceeded its worst case, counted floats rather than entropy-coded bits, and required a GPU decoder.Source: §1 · p. 2
  • Measurements identify prediction from each curve’s own past as the largest saving at production precision, followed by hierarchy-aware, per-joint sample omission.On the gaps left by the encoder, a nearest-neighbour oracle with millions of training samples is no better than linear interpolation, and learned in-betweeners did not pay for themselves.Source: §1 · p. 2
  • The paper treats codec measurements under an explicit error contract and exact bit count as a way to locate motion redundancy and decide where learning pays.The motivation is that morphology and dynamics determine much of how joints move, while production codecs must serve arbitrary skeletons and bound error.Source: §1 · p. 2
  • The codec represents each sub-track as a curve, selects quantization steps and keys in closed loop, and entropy-codes prediction residuals under a small learned model.The model uses no joint identity, and integer inference is bit-exact on ARM and x86; each decoded clip is checked against ACL’s worst-case-per-joint or mean-per-clip contract.Source: §1 · p. 2
  • CurveCodec 2 uses 0.37× ACL’s bytes at 0.01 cm under the worst-case contract and 0.22× at 0.1 cm under either contract.The corpus contains 906 hours from 33 datasets with a held-out test side.Source: §1 · p. 2

2 Related Work

Prior work spans hand-engineered animation compression, learned motion representations, and learned probability models. CurveCodec 2 combines an explicit verifiable codec with learning where measurements indicate it helps: modeling residual probabilities.

2.1 Hand-engineered Animation Compression

  • Hand-engineered methods exploit trajectories, transforms, prediction, and selected samples; ACL prioritizes per-track processing and constant-time random access over compression ratio.CurveCodec 2 selects keys by rate-distortion optimization against whole-subtree object-space error rather than a local error or saliency criterion.Source: §2.1 · p. 3

2.2 Learned Motion Representations and Codecs

  • Learned motion representations target synthesis, control, or pose-level transfer rather than decodable bitstreams at stated precision; CurveCodec 2 moves its predecessor’s learned prior from interpolation to probability modeling.The authors report precision floors for methods they measured and do not extend those bounds to methods they did not measure.Source: §2.2 · p. 3

2.3 Entropy Coding and Learned Probability Models

  • Lossless coding separates prediction from symbol coding, and CurveCodec 2 adopts per-curve residual modeling with a learned probability model and deterministic integer inference.The paper distinguishes this from prior learned motion and mesh coders that do not hold an object-space worst-case bound through a skeleton.Source: §2.3 · p. 3

3 Preliminaries

The preliminaries define the skeletal data and error measure, describe a two-stage compression pipeline, and specify contracts that compare decoded clips with ACL’s measured results.

3.1 Skeletal Animation and Error

  • A skeleton is a rooted joint tree, and a sub-track is one transform component’s time series; the same codec and weights apply across joint counts and tree topologies without retraining.Shell error uses forward-kinematic object-space transforms and the largest displacement of three virtual vertices; joint error therefore includes ancestor errors.Source: §3.1 · pp. 3–4

3.2 Two-Stage Compression Pipeline

  • At 0.01 cm, the two-stage pipeline estimates 32.6 GB for ACL and 11.9 GB for CurveCodec 2 after shared preprocessing.Preprocessing drops absent scale tracks and folds tracks that do not move; CurveCodec 2 then uses log-map curves, closed-loop quantization and keys, prediction, and learned entropy coding.Source: Figure 2 · p. 4, §3.2 · p. 4

3.1 Skeletal Animation and Error

  • Both codecs use ACL’s shell-error approximation at sample times, which can understate the sphere’s largest displacement by up to a factor of 2/3 for pure rotation error.The benchmarked ACL commit uses this approximation; its development branch has since replaced it with the exact maximum.Source: §3.1 · p. 4

3.3 Error Contracts

  • The max gate keeps each joint within 5% of the larger of the target precision and ACL’s own maximum, while also matching ACL’s share of samples above precision within half a percentage point.Every stream is checked, with re-encoding or ACL-stream fallback when needed; reported byte counts include fallback.Source: §3.3 · pp. 4–5
  • The mean gate preserves ACL’s clip mean while guarding worst-case error at ten times ACL’s clip mean, making it suited to storage at tight precision.At loose precision, the guard admits large isolated errors.Source: §3.3 · p. 4

4 CurveCodec 2

CurveCodec 2 represents animated sub-tracks as curves and separates lossy rate–distortion choices from lossless entropy coding. Its encoder tests decoded candidates against the error contract, while a learned model codes residuals from each curve’s own past.

4 CurveCodec 2

  • CurveCodec 2 codes each animated sub-track as a curve, making lossy rate–distortion decisions separately from lossless coding of the resulting integers.The encoder checks candidate changes against subtree shell error; the learned model affects bit costs, not the decoded clip’s error contract.Source: §4 · p. 5, Figure 3 · p. 6

4.1 Representation

  • Rotations use log-map vectors, avoiding the precision floor associated with reconstructing a quaternion component, while translations are coded in centimetres without a transform.Quaternion sign continuity keeps consecutive samples in the same hemisphere; a full-turn discontinuity can cost keys but does not violate the decoded-clip contract.Source: §4.1 · p. 5

4.2 Closed-Loop Quantization

  • Quantization steps are grown in closed loop through the hierarchy: each candidate is decoded and tested against the error contract on every joint in the affected subtree.The search alternates leaf-to-root and root-to-leaf; under the max gate, rotation components may then grow separately.Source: §4.2 · p. 5

4.3 Rate–Distortion Keys

  • Tracks are thinned by removing keys only when decoded subtree errors remain within the contract; under the mean gate, key removal and step growth compete by distortion per estimated rate.The mean-gate budget is spent about 60% on steps and 40% on keys, and each track uses the cheapest of four coding modes.Source: §4.3 · pp. 5–6

4.4 Prediction and Learned Entropy Coding

  • A fixed predictor forms residuals from each column’s own past, and a learned causal model assigns symbol probabilities for rANS coding.The model uses decoded-past features without joint, skeleton, or dataset identity; fixed-point inference makes probabilities and decoded integers identical across platforms.Source: §4.4 · pp. 6–7

5 Where Is the Redundancy in Motion?

Measurements locate motion redundancy in ACL’s staged compression, temporal prediction, per-joint key selection, and residual statistics. They show which tested structures and learned roles reduce rate under the development-set error contracts.

5.1 ACL’s Bit Budget

  • 2.84×: folding cuts ACL from 191 to 68 bits per joint-sample; range reduction with variable bit widths adds 3.74×, to 18.1 bits.ACL’s zeroth-order entropy is 97.7% of its spent bits, while first- and second-difference costs reach 83.8% and 81.1%.Source: §5.1 · p. 7

5.2 Samples Predicted and Samples Not Coded

  • 39–55%: predicting each quantized log-map integer from its own past reduces its stream versus zeroth-order coding; adaptive prediction wins on 37–44% of curves.The best predictor varies by joint depth: second differences beat first differences by 18% at the root but only 4–7% at depth six and below.Source: §5.2 · p. 7
  • 87% versus 57%: at 0.01 cm, the max-gate encoder keeps these root versus depth-six-and-below sample shares; at 0.1 cm, it keeps 51% versus 22%.At 0.1 cm, removing a key adds about 0.03 distortion units per bit saved, versus 0.17 for growing a step and 0.31 for a dead zone; held-out key removal costs 8% at 0.01 cm and 69% at 1 cm.Source: §5.2 · p. 7

5.3 Interpolation Gains Little on the Gaps the Encoder Leaves

  • 0.85–0.90: the nearest-neighbour oracle reaches this k on iso-mean RD gaps, no better than linear interpolation, while tested in-betweeners changed codec size by −2.5% to +5.7%.The oracle improved cubic interpolation by up to 1.37× on random gaps, but its RD-gap result stayed flat over the measured 32-fold library-size range.Source: §5.3 · p. 8, Figure 6 · p. 8

5.4 Where a Network Pays

  • 7–12%: learning the entropy model saves this much in the lifting-wavelet codec, while learning its transform changes size by ±1%.The residual model captures slowly varying per-curve regimes rather than predicting the next residual value; eight context positions provide 60–70% of its gain.Source: §5.4 · p. 9

6 Experiments

On a held-out test side of 4,472 clips, CurveCodec 2 is evaluated against ACL under explicit error contracts. It reduces storage, with prediction providing the largest ablation gain at production precision.

6.1 Setup

  • The held-out test side contains 4,472 clips, 20.1 hours, and 342.7 million joint-samples, split by take group to prevent related takes crossing the split.The dog dataset is held out of training entirely; ACL is run at seven precisions, and both codecs are timed on one pinned CPU core.Source: §6.1 · p. 9

6.2 Compression against ACL

  • At 0.01 cm, CurveCodec 2 uses 0.37× ACL’s bytes under either contract on the held-out test side.The test side contains 4,472 clips from 33 datasets; ratios include fallback streams for clips that fail their contract.Source: Figure 7 · p. 9, §6.2 · p. 9, Table 2 · p. 10

6.3 Contracts: Tolerances and Failures

  • At p≤0.1 cm, first-pass encoding passes on at least 99.6% of clips under either contract; fallback resolves the remaining failures.At 0.3 and 1 cm, some max-gate clips fail because late step refinement cannot un-fold a track already exceeding the contract.Source: §6.3 · p. 10

6.4 Generalization

  • Every dataset is smaller than ACL at every precision, including the dog species absent from training; gains vary with clip length and frame rate.The authors note that frame-rate classes are partly confounded with datasets.Source: §6.4 · p. 10, Table 3 · p. 10

6.5 Ablation

  • Prediction is the largest component at p≤0.1 cm, worth 2.0× and 2.2× against general-purpose compression; keys matter increasingly as precision loosens.The entropy model saves 3–6% under the max gate and 7–10% under the mean gate; the final step search and container save 1–8%.Source: §6.5 · pp. 10–11, Table 4 · p. 12

6.6 Runtime and Deployment

  • The product codec decodes 1 million joint-samples in 2.1 seconds on one core, 168× ACL’s decode time.It takes 57 seconds to encode the same number of joint-samples, 12× ACL’s encode time.Source: §6.6 · pp. 11–12

6.7 Failure Cases

  • At p≥0.3 cm, the authors do not recommend the mean gate: its guard admits worst-case errors up to 24.7 cm at 1 cm on a handful of clips.The mean gate’s weakest savings occur on short, low-rate clips of small skeletons, where headers and model cold starts are amortized over few samples.Source: §6.7 · p. 12, Figure 11 · p. 12

7 Limitations

The codec is designed for whole-clip storage and distribution rather than random-access runtime use; its contracts are relative to ACL, and its motion-structure findings are not validated as a representation.

7 Limitations

  • 38–168× ACL’s decompression time is required for a full clip on one core, and CurveCodec 2 cannot provide constant-time single-pose access.It decodes whole clips at load time; ACL can selectively decompress poses during runtime evaluation.Source: §7 · p. 12
  • The max gate preserves ACL’s worst case only within 5% tolerance, with errors bounded at sample times rather than between them.The contracts inherit ACL’s misses at loose precision; the standalone p-based contract was tested only on a subset.Source: §7 · p. 12
  • The codec and entropy model were not evaluated on generative or recognition tasks, and tested negative findings do not rule out better models.Those findings cover the estimators, data, and precisions tried, using one architecture and training run.Source: §7 · p. 12

8 Conclusion

Measurements identify temporal prediction and hierarchy-aware sample omission as the main sources of redundancy reduction, while tested interpolation methods offer no gain over linear interpolation. CurveCodec 2 combines these findings with learned residual coding to compress skeletal motion under ACL-relative error contracts.

8 Conclusion

  • Predicting each quantized curve from its own past gives the largest saving at tight precision; per-joint sample omission is second and grows until comparable at 1 cm.Sample choices are made in closed loop through the hierarchy.Source: §8 · p. 12
  • 0.37× ACL’s bytes at ACL’s default precision under the worst-case contract within tolerance, and 0.22× at 0.1 cm at mean error.One model serves every tested rig, including a species absent from training.Source: §8 · p. 13
  • None of the tested interpolators, including a retrieval oracle over millions of training samples, beats linear interpolation.The authors conclude that a learned in-betweener had little left to learn on the encoder’s gaps.Source: §8 · p. 13
  • A network pays as the probability model of the residuals the codec must send; capturing each curve’s residual regime and hierarchy-aware sample choices is proposed as a next step for learned motion models.The paper identifies these as the two parts that carry the codec’s gain.Source: §8 · p. 13

Related papers

Loading 2610.04211v1…