EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Refactor opusenc for strict Clippy checks
Dylan M. Taylor7c27d880309e
diff --git a/crates/opusenc/src/bands.rs b/crates/opusenc/src/bands.rsindex 744de3fe3..cf3c590e8 100644--- a/crates/opusenc/src/bands.rs+++ b/crates/opusenc/src/bands.rs@@ -8,7 +8,8 @@use crate::range::{BITRES, RangeEncoder, ilog};use crate::rate::{Mode, QTHETA_OFFSET, get_pulses};-use crate::tables::*;+use crate::tables::EBANDS;+use crate::{CeltFrame, rate::Allocation};pub const SPREAD_NORMAL: usize = 2;@@ -55,7 +56,7 @@ fn exp_rotation1_inv(x: &mut [f32], len: usize, stride: usize, c: f32, s: f32) {if len <= stride {return;}- if len >= 2 * stride + 1 {+ if len > 2 * stride {for i in 0..=len - 2 * stride - 1 {let x1 = x[i];let x2 = x[i + stride];@@ -217,7 +218,7 @@ impl BandEnc<'_, '_> {let q = qn as u32;let half = q >> 1;let ft = (half + 1) * (half + 1);- let (fl, fs) = if it <= half { (it * (it + 1) >> 1, it + 1) } else { (ft - ((q + 1 - it) * (q + 2 - it) >> 1), q + 1 - it) };+ let (fl, fs) = if it <= half { ((it * (it + 1)) >> 1, it + 1) } else { (ft - (((q + 1 - it) * (q + 2 - it)) >> 1), q + 1 - it) };self.enc.encode(fl, fl + fs, ft);itheta = ((it * 16384) / q) as i32;}@@ -294,26 +295,19 @@ impl BandEnc<'_, '_> {}}-/// Codes all band shapes (`quant_all_bands`, encoder side, long blocks). `x` holds `c` channels-/// of `n` normalised MDCT coefficients each.-#[allow(clippy::too_many_arguments)]-pub fn quant_all_bands(- m: &Mode,- start: usize,- end: usize,- x: &[f32],- n_total: usize,- c: usize,- pulses: &[i32; NB_EBANDS],- spread: usize,- dual_stereo: bool,- intensity: usize,- total_bits: i32,- mut balance: i32,- enc: &mut RangeEncoder,- lm: usize,- coded_bands: usize,-) {+/// Shape-coding controls, independent of the selected band allocation.+pub struct BandCoding {+ pub spread: usize,+ pub total_bits: i32,+}++/// Codes all band shapes (`quant_all_bands`, encoder side, long blocks). `x` holds+/// `frame.channels` channels of `n_total` normalised MDCT coefficients each.+pub fn quant_all_bands(m: &Mode, frame: CeltFrame, x: &[f32], n_total: usize, allocation: &Allocation, coding: BandCoding, enc: &mut RangeEncoder) {+ let CeltFrame { start, end, channels: c, lm } = frame;+ let Allocation { pulses, dual_stereo, intensity, coded_bands, balance, .. } = allocation;+ let (dual_stereo, intensity, coded_bands, mut balance) = (*dual_stereo, *intensity, *coded_bands, *balance);+ let BandCoding { spread, total_bits } = coding;let mm = 1usize << lm;debug_assert!(c == 1 || dual_stereo || intensity <= start, "stereo frames are coded as dual stereo");let mut ctx = BandEnc { m, enc, i: 0, spread, remaining_bits: 0, pvq_v: Vec::new(), iy: Vec::new(), tmp: Vec::new() };@@ -362,7 +356,7 @@ mod tests {x[i + stride] = c * x2 + s * x1;x[i] = c * x1 + ms * x2;}- if len >= 2 * stride + 1 {+ if len > 2 * stride {for i in (0..=len - 2 * stride - 1).rev() {let x1 = x[i];let x2 = x[i + stride];diff --git a/crates/opusenc/src/energy.rs b/crates/opusenc/src/energy.rsindex 0057ae33a..1d4b12719 100644--- a/crates/opusenc/src/energy.rs+++ b/crates/opusenc/src/energy.rs@@ -4,9 +4,10 @@//! The quantised energies are updated with exactly the decoder's arithmetic so the prediction//! state never drifts between encoder and decoder.+use crate::CeltFrame;use crate::range::RangeEncoder;-use crate::rate::MAX_FINE_BITS;-use crate::tables::*;+use crate::rate::{Allocation, MAX_FINE_BITS};+use crate::tables::{BETA_COEF, BETA_INTRA, E_PROB_MODEL, NB_EBANDS, PRED_COEF, SMALL_ENERGY_ICDF};const LAPLACE_MINP: u32 = 1;const LAPLACE_NMIN: u32 = 16;@@ -56,18 +57,8 @@ pub fn laplace_encode(enc: &mut RangeEncoder, value: i32, mut fs: u32, decay: u3/// `quant_coarse_energy` for one prediction mode. `e` holds the target log2 energies (relative/// to `E_MEANS`), `old_e` the quantised energies, updated in place. `budget` is the frame size in/// bits.-#[allow(clippy::too_many_arguments)]-pub fn quant_coarse_energy(- start: usize,- end: usize,- e: &[f32; 2 * NB_EBANDS],- old_e: &mut [f32; 2 * NB_EBANDS],- intra: bool,- enc: &mut RangeEncoder,- c: usize,- lm: usize,- budget: i32,-) {+pub fn quant_coarse_energy(frame: CeltFrame, e: &[f32; 2 * NB_EBANDS], old_e: &mut [f32; 2 * NB_EBANDS], intra: bool, enc: &mut RangeEncoder, budget: i32) {+ let CeltFrame { start, end, channels: c, lm } = frame;let prob = &E_PROB_MODEL[lm][intra as usize];let (coef, beta) = if intra { (0.0, BETA_INTRA) } else { (PRED_COEF[lm], BETA_COEF[lm]) };let mut prev = [0f32; 2];@@ -111,15 +102,8 @@ pub fn quant_coarse_energy(}/// `quant_fine_energy`: raw bits refining each band's quantised energy.-pub fn quant_fine_energy(- start: usize,- end: usize,- e: &[f32; 2 * NB_EBANDS],- old_e: &mut [f32; 2 * NB_EBANDS],- fine_quant: &[i32; NB_EBANDS],- enc: &mut RangeEncoder,- c: usize,-) {+pub fn quant_fine_energy(frame: CeltFrame, e: &[f32; 2 * NB_EBANDS], old_e: &mut [f32; 2 * NB_EBANDS], fine_quant: &[i32; NB_EBANDS], enc: &mut RangeEncoder) {+ let CeltFrame { start, end, channels: c, .. } = frame;for i in start..end {let fq = fine_quant[i];if fq <= 0 {@@ -139,18 +123,16 @@ pub fn quant_fine_energy(/// `quant_energy_finalise`: spends the bits left at the end of the frame on one more bit of/// energy resolution per band, in priority order.-#[allow(clippy::too_many_arguments)]pub fn quant_energy_finalise(- start: usize,- end: usize,+ frame: CeltFrame,e: &[f32; 2 * NB_EBANDS],old_e: &mut [f32; 2 * NB_EBANDS],- fine_quant: &[i32; NB_EBANDS],- fine_priority: &[i32; NB_EBANDS],+ allocation: &Allocation,mut bits_left: i32,enc: &mut RangeEncoder,- c: usize,) {+ let CeltFrame { start, end, channels: c, .. } = frame;+ let Allocation { fine_quant, fine_priority, .. } = allocation;for prio in 0..2 {let mut i = start;while i < end && bits_left >= c as i32 {diff --git a/crates/opusenc/src/lib.rs b/crates/opusenc/src/lib.rsindex 9cc1f6a51..b4346ebd6 100644--- a/crates/opusenc/src/lib.rs+++ b/crates/opusenc/src/lib.rs@@ -24,8 +24,6 @@//! ```#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]-// The bit-allocation code mirrors the normative integer arithmetic; keep C-like shift expressions.-#![allow(clippy::precedence, clippy::int_plus_one)]mod bands;mod energy;@@ -38,14 +36,23 @@ mod tables;use std::sync::OnceLock;-use bands::{SPREAD_NORMAL, quant_all_bands};+use bands::{BandCoding, SPREAD_NORMAL, quant_all_bands};use energy::{quant_coarse_energy, quant_energy_finalise, quant_fine_energy};use mdct::Mdct;use range::{BITRES, RangeEncoder};-use rate::{Mode as CeltMode, compute_allocation};+use rate::{AllocationInput, Mode as CeltMode, compute_allocation};use resample::Downsampler;use silk::SilkEncoder;-use tables::*;+use tables::{E_MEANS, EBANDS, NB_EBANDS, OVERLAP, PREEMPH, SPREAD_ICDF, TF_SELECT_TABLE, TRIM_ICDF};++/// Band range, channel count and transform size shared by CELT coding stages.+#[derive(Clone, Copy)]+struct CeltFrame {+ start: usize,+ end: usize,+ channels: usize,+ lm: usize,+}/// Samples per channel in one 20 ms frame at 48 kHz.const N: usize = 960;@@ -314,7 +321,7 @@ impl OpusEncoder {Mode::Celt => {let (log_e, silence) = self.celt_analysis(pcm);let len = self.frame_bytes;- packet.extend_from_slice(&self.encode_celt(RangeEncoder::new(), len, 0, NB_EBANDS, &log_e, silence));+ packet.extend_from_slice(&self.encode_celt(RangeEncoder::new(), len, 0..NB_EBANDS, &log_e, silence));}Mode::Silk => {let x = self.silk_input(pcm);@@ -344,7 +351,7 @@ impl OpusEncoder {}let (log_e, _) = self.celt_analysis(pcm);let end = if self.bandwidth == Bandwidth::SuperWideband { 19 } else { NB_EBANDS };- packet.extend_from_slice(&self.encode_celt(enc, len, HYBRID_START_BAND, end, &log_e, false));+ packet.extend_from_slice(&self.encode_celt(enc, len, HYBRID_START_BAND..end, &log_e, false));}}packet@@ -406,10 +413,11 @@ impl OpusEncoder {/// Codes one CELT frame (RFC 6716 §4.3, in bitstream order) of `len` bytes into `enc`/// (which already holds the SILK frame in hybrid mode), coding bands `start..end`, and/// finalises the frame.- #[allow(clippy::too_many_arguments)]- fn encode_celt(&mut self, mut enc: RangeEncoder, len: usize, start: usize, end: usize, log_e: &[f32; 2 * NB_EBANDS], silence: bool) -> Vec<u8> {+ fn encode_celt(&mut self, mut enc: RangeEncoder, len: usize, bands: std::ops::Range<usize>, log_e: &[f32; 2 * NB_EBANDS], silence: bool) -> Vec<u8> {let m = celt_mode();let c = self.channels;+ let frame = CeltFrame { start: bands.start, end: bands.end, channels: c, lm: LM };+ let CeltFrame { start, end, .. } = frame;if c == 1 {for i in 0..NB_EBANDS {self.old_band_e[i] = self.old_band_e[i].max(self.old_band_e[NB_EBANDS + i]);@@ -438,10 +446,10 @@ impl OpusEncoder {let mut enc_intra = enc.clone();let mut old_intra = self.old_band_e;enc_intra.bit_logp(true, 3);- quant_coarse_energy(start, end, log_e, &mut old_intra, true, &mut enc_intra, c, LM, total_bits_raw);+ quant_coarse_energy(frame, log_e, &mut old_intra, true, &mut enc_intra, total_bits_raw);enc.bit_logp(false, 3);let mut old_inter = self.old_band_e;- quant_coarse_energy(start, end, log_e, &mut old_inter, false, &mut enc, c, LM, total_bits_raw);+ quant_coarse_energy(frame, log_e, &mut old_inter, false, &mut enc, total_bits_raw);if enc_intra.tell_frac() < enc.tell_frac() {enc = enc_intra;self.old_band_e = old_intra;@@ -449,14 +457,14 @@ impl OpusEncoder {self.old_band_e = old_inter;}} else {- quant_coarse_energy(start, end, log_e, &mut self.old_band_e, false, &mut enc, c, LM, total_bits_raw);+ quant_coarse_energy(frame, log_e, &mut self.old_band_e, false, &mut enc, total_bits_raw);}// TF resolution: no changes.{let mut budget = total_bits_raw;let mut tell = enc.tell();let mut logp = 4;- let tf_select_rsv = LM > 0 && tell + logp + 1 <= budget;+ let tf_select_rsv = LM > 0 && tell + logp < budget;budget -= tf_select_rsv as i32;for _ in start..end {if tell + logp <= budget {@@ -488,27 +496,11 @@ impl OpusEncoder {enc.icdf(alloc_trim as usize, &TRIM_ICDF, 7);}let bits = (total_bits_raw << BITRES) - enc.tell_frac() - 1;- let alloc = compute_allocation(m, start, end, &offsets, &cap, alloc_trim, bits, c, LM, &mut enc);- quant_fine_energy(start, end, log_e, &mut self.old_band_e, &alloc.fine_quant, &mut enc, c);- quant_all_bands(- m,- start,- end,- &self.freq,- N,- c,- &alloc.pulses,- SPREAD_NORMAL,- alloc.dual_stereo,- alloc.intensity,- total_bits_raw << BITRES,- alloc.balance,- &mut enc,- LM,- alloc.coded_bands,- );+ let alloc = compute_allocation(m, frame, AllocationInput { offsets: &offsets, cap: &cap, trim: alloc_trim, bits }, &mut enc);+ quant_fine_energy(frame, log_e, &mut self.old_band_e, &alloc.fine_quant, &mut enc);+ quant_all_bands(m, frame, &self.freq, N, &alloc, BandCoding { spread: SPREAD_NORMAL, total_bits: total_bits_raw << BITRES }, &mut enc);let bits_left = total_bits_raw - enc.tell();- quant_energy_finalise(start, end, log_e, &mut self.old_band_e, &alloc.fine_quant, &alloc.fine_priority, bits_left, &mut enc, c);+ quant_energy_finalise(frame, log_e, &mut self.old_band_e, &alloc, bits_left, &mut enc);debug_assert!(enc.tell() <= total_bits_raw, "frame overflow: {} > {}", enc.tell(), total_bits_raw);if c == 1 {let (a, b) = self.old_band_e.split_at_mut(NB_EBANDS);diff --git a/crates/opusenc/src/rate.rs b/crates/opusenc/src/rate.rsindex a6ae81f5c..ff6ccae95 100644--- a/crates/opusenc/src/rate.rs+++ b/crates/opusenc/src/rate.rs@@ -4,8 +4,9 @@//! spec-derived `filmcraft-opus` decoder (first-party, MIT OR Apache-2.0) step by step; the only//! difference is that the encoder *writes* the band-skip, intensity and dual-stereo symbols.+use crate::CeltFrame;use crate::range::{BITRES, RangeEncoder, ilog};-use crate::tables::*;+use crate::tables::{ALLOC, EBANDS, LOG2_FRAC_TABLE, MAX_LM, NB_EBANDS};const MAX_PSEUDO: i32 = 40;const LOG_MAX_PSEUDO: i32 = 6;@@ -127,7 +128,7 @@ impl Mode {let mut cap = [0i32; NB_EBANDS];for (i, cp) in cap.iter_mut().enumerate() {let n = (EBANDS[i + 1] - EBANDS[i]) << lm;- *cp = (self.caps[NB_EBANDS * (2 * lm + c - 1) + i] as i32 + 64) * c as i32 * n >> 2;+ *cp = ((self.caps[NB_EBANDS * (2 * lm + c - 1) + i] as i32 + 64) * c as i32 * n) >> 2;}cap}@@ -200,7 +201,7 @@ fn compute_caps(m: &Mode) -> Vec<u8> {let mut n0 = EBANDS[j + 1] - EBANDS[j];let max_bits = if n0 << i == 1 {- c * (1 + MAX_FINE_BITS) << BITRES+ (c * (1 + MAX_FINE_BITS)) << BITRES} else {let mut lm0 = 0;if n0 > 2 {@@ -240,7 +241,7 @@ fn compute_caps(m: &Mode) -> Vec<u8> {let num = mb + ndof * offset;let den = (ndof - 1) << BITRES;let qb = ((num + (den >> 1)) / den).min(MAX_FINE_BITS);- mb += c * qb << BITRES;+ mb += (c * qb) << BITRES;mb};let w = c * ((EBANDS[j + 1] - EBANDS[j]) << i);@@ -263,21 +264,19 @@ pub struct Allocation {pub fine_priority: [i32; NB_EBANDS],}+/// Per-band limits, boosts and available budget for the allocation search.+pub struct AllocationInput<'a> {+ pub offsets: &'a [i32; NB_EBANDS],+ pub cap: &'a [i32; NB_EBANDS],+ pub trim: i32,+ pub bits: i32,+}+/// `clt_compute_allocation`, encoder side. Stereo frames are always coded as dual (L/R) stereo/// with no intensity bands, and no band is skipped voluntarily.-#[allow(clippy::too_many_arguments)]-pub fn compute_allocation(- m: &Mode,- start: usize,- end: usize,- offsets: &[i32; NB_EBANDS],- cap: &[i32; NB_EBANDS],- alloc_trim: i32,- total: i32,- c: usize,- lm: usize,- enc: &mut RangeEncoder,-) -> Allocation {+pub fn compute_allocation(m: &Mode, frame: CeltFrame, input: AllocationInput<'_>, enc: &mut RangeEncoder) -> Allocation {+ let CeltFrame { start, end, channels: c, lm } = frame;+ let AllocationInput { offsets, cap, trim: alloc_trim, bits: total } = input;let ci = c as i32;let lmi = lm as i32;let mut total = total.max(0);@@ -302,8 +301,8 @@ pub fn compute_allocation(let mut trim_offset = [0i32; NB_EBANDS];for j in start..end {let w = EBANDS[j + 1] - EBANDS[j];- thresh[j] = (ci << BITRES).max((3 * w << lmi << BITRES) >> 4);- trim_offset[j] = ci * w * (alloc_trim - 5 - lmi) * (end as i32 - j as i32 - 1) * (1 << (lmi + BITRES as i32)) >> 6;+ thresh[j] = (ci << BITRES).max(((3 * w) << lmi << BITRES) >> 4);+ trim_offset[j] = (ci * w * (alloc_trim - 5 - lmi) * (end as i32 - j as i32 - 1) * (1 << (lmi + BITRES as i32))) >> 6;if w << lmi == 1 {trim_offset[j] -= ci << BITRES;}@@ -317,7 +316,7 @@ pub fn compute_allocation(let mid = (lo + hi) >> 1;for j in (start..end).rev() {let n = EBANDS[j + 1] - EBANDS[j];- let mut bitsj = ci * n * (ALLOC[mid as usize][j] as i32) << lmi >> 2;+ let mut bitsj = (ci * n * (ALLOC[mid as usize][j] as i32)) << lmi >> 2;if bitsj > 0 {bitsj = (bitsj + trim_offset[j]).max(0);}@@ -342,8 +341,8 @@ pub fn compute_allocation(lo -= 1;for j in start..end {let n = EBANDS[j + 1] - EBANDS[j];- let mut bits1j = ci * n * (ALLOC[lo as usize][j] as i32) << lmi >> 2;- let mut bits2j = if hi >= nb_alloc { cap[j] } else { ci * n * (ALLOC[hi as usize][j] as i32) << lmi >> 2 };+ let mut bits1j = (ci * n * (ALLOC[lo as usize][j] as i32)) << lmi >> 2;+ let mut bits2j = if hi >= nb_alloc { cap[j] } else { (ci * n * (ALLOC[hi as usize][j] as i32)) << lmi >> 2 };if bits1j > 0 {bits1j = (bits1j + trim_offset[j]).max(0);}@@ -361,27 +360,27 @@ pub fn compute_allocation(bits1[j] = bits1j;bits2[j] = bits2j;}- interp_bits2pulses(m, start, end, skip_start, &bits1, &bits2, &thresh, cap, total, skip_rsv, intensity_rsv, dual_stereo_rsv, c, lm, enc)+ let interpolation =+ AllocationInterpolation { skip_start, bits1: &bits1, bits2: &bits2, thresh: &thresh, cap, total, skip_rsv, intensity_rsv, dual_stereo_rsv };+ interp_bits2pulses(m, frame, interpolation, enc)}-#[allow(clippy::too_many_arguments)]-fn interp_bits2pulses(- m: &Mode,- start: usize,- end: usize,+/// Bracketing allocation vectors and signalling reserves for the interpolation stage.+struct AllocationInterpolation<'a> {skip_start: usize,- bits1: &[i32; NB_EBANDS],- bits2: &[i32; NB_EBANDS],- thresh: &[i32; NB_EBANDS],- cap: &[i32; NB_EBANDS],- mut total: i32,+ bits1: &'a [i32; NB_EBANDS],+ bits2: &'a [i32; NB_EBANDS],+ thresh: &'a [i32; NB_EBANDS],+ cap: &'a [i32; NB_EBANDS],+ total: i32,skip_rsv: i32,- mut intensity_rsv: i32,- mut dual_stereo_rsv: i32,- c: usize,- lm: usize,- enc: &mut RangeEncoder,-) -> Allocation {+ intensity_rsv: i32,+ dual_stereo_rsv: i32,+}++fn interp_bits2pulses(m: &Mode, frame: CeltFrame, interpolation: AllocationInterpolation<'_>, enc: &mut RangeEncoder) -> Allocation {+ let CeltFrame { start, end, channels: c, lm } = frame;+ let AllocationInterpolation { skip_start, bits1, bits2, thresh, cap, mut total, skip_rsv, mut intensity_rsv, mut dual_stereo_rsv } = interpolation;let ci = c as i32;let alloc_floor = ci << BITRES;let stereo = (c > 1) as i32;@@ -393,7 +392,7 @@ fn interp_bits2pulses(let mut psum = 0;let mut done = false;for j in (start..end).rev() {- let tmp = bits1[j] + (mid * bits2[j] >> ALLOC_STEPS);+ let tmp = bits1[j] + ((mid * bits2[j]) >> ALLOC_STEPS);if tmp >= thresh[j] || done {done = true;psum += tmp.min(cap[j]);@@ -411,7 +410,7 @@ fn interp_bits2pulses(let mut psum = 0;let mut done = false;for j in (start..end).rev() {- let mut tmp = bits1[j] + (lo * bits2[j] >> ALLOC_STEPS);+ let mut tmp = bits1[j] + ((lo * bits2[j]) >> ALLOC_STEPS);if tmp < thresh[j] && !done {tmp = if tmp >= alloc_floor { alloc_floor } else { 0 };} else {@@ -500,9 +499,9 @@ fn interp_bits2pulses(if n == 2 {offset += (den << BITRES) >> 2;}- if bits[j] + offset < den * 2 << BITRES {+ if bits[j] + offset < (den * 2) << BITRES {offset += nclogn >> 2;- } else if bits[j] + offset < den * 3 << BITRES {+ } else if bits[j] + offset < (den * 3) << BITRES {offset += nclogn >> 3;}let mut eb = (bits[j] + offset + (den << (BITRES - 1))).max(0);@@ -513,7 +512,7 @@ fn interp_bits2pulses(eb = eb.min(MAX_FINE_BITS);ebits[j] = eb;fine_priority[j] = (eb * (den << BITRES) >= bits[j] + offset) as i32;- bits[j] -= ci * eb << BITRES;+ bits[j] -= (ci * eb) << BITRES;} else {excess = (bit - (ci << BITRES)).max(0);bits[j] = bit - excess;@@ -523,7 +522,7 @@ fn interp_bits2pulses(if excess > 0 {let extra_fine = (excess >> (stereo + BITRES as i32)).min(MAX_FINE_BITS - ebits[j]);ebits[j] += extra_fine;- let extra_bits = extra_fine * ci << BITRES;+ let extra_bits = (extra_fine * ci) << BITRES;fine_priority[j] = (extra_bits >= excess - balance) as i32;excess -= extra_bits;}diff --git a/crates/opusenc/src/silk.rs b/crates/opusenc/src/silk.rsindex c7a4b8692..2678a96a0 100644--- a/crates/opusenc/src/silk.rs+++ b/crates/opusenc/src/silk.rs@@ -16,8 +16,12 @@ mod pulses;#[allow(dead_code)]pub(crate) mod tables;-use lpc::*;-use tables::*;+use lpc::{MAX_LPC_ORDER, div32_varq, inverse32_varq, nlsf2a, rshift_round, sat16, smlawb, smulwb, smulww};+use tables::{+ DELTA_GAIN, GAIN_MSB, LTP_FILTER, LTP_PERIODICITY, LTP_SCALE, LTP_TAPS_0, LTP_TAPS_1, LTP_TAPS_2, MID_ONLY, NLSF_EXT, NLSF_INTERP, NLSF_SEL_NBMB,+ NLSF_SEL_WB, NLSF_STAGE1, NLSF_STAGE2, PITCH_CONTOUR, PITCH_HIGH, PITCH_LOW, STEREO_PRED_JOINT, STEREO_WEIGHTS_Q13, TYPE_ACTIVE, TYPE_INACTIVE, UNIFORM3,+ UNIFORM4, UNIFORM5, UNIFORM8,+};use crate::range::RangeEncoder;diff --git a/crates/opusenc/src/silk/analysis.rs b/crates/opusenc/src/silk/analysis.rsindex de510433e..439331076 100644--- a/crates/opusenc/src/silk/analysis.rs+++ b/crates/opusenc/src/silk/analysis.rs@@ -1,7 +1,7 @@//! Encoder-side signal analysis for SILK (own design): windowed autocorrelation LPC, LPC → NLSF//! conversion, open-loop pitch search and LTP codebook search.-use super::tables::*;+use super::tables::{CB_NB_20, CB_WB_20, LTP_FILTER, LTP_PERIODICITY, LTP_TAPS_0, LTP_TAPS_1, LTP_TAPS_2};/// Short-term prediction coefficients `a` (prediction `x[n] ≈ Σ a[j] x[n-1-j]`) from the/// windowed segment `x`, with a Gaussian lag window and white-noise correction.diff --git a/crates/opusenc/src/silk/lpc.rs b/crates/opusenc/src/silk/lpc.rsindex 7846d2973..e0f8c107e 100644--- a/crates/opusenc/src/silk/lpc.rs+++ b/crates/opusenc/src/silk/lpc.rs@@ -5,7 +5,10 @@//! spec-derived `filmcraft-opus` decoder (MIT OR Apache-2.0): the encoder must reconstruct the//! quantised NLSFs and LPC coefficients bit-exactly as the decoder does.-use super::tables::*;+use super::tables::{+ COS_Q12, LSF_ORDER_NBMB, LSF_ORDER_WB, NLSF_CB_NBMB, NLSF_CB_WB, NLSF_MIN_SPACING_NBMB, NLSF_MIN_SPACING_WB, NLSF_PRED_NBMB, NLSF_PRED_WB, NLSF_PSEL_NBMB,+ NLSF_PSEL_WB,+};pub const MAX_LPC_ORDER: usize = 16;diff --git a/crates/opusenc/src/silk/nlsf.rs b/crates/opusenc/src/silk/nlsf.rsindex 3f1f17ac6..4695152ff 100644--- a/crates/opusenc/src/silk/nlsf.rs+++ b/crates/opusenc/src/silk/nlsf.rs@@ -3,7 +3,9 @@//! dequantisation exactly. The search strategy is our own.use super::lpc::{MAX_LPC_ORDER, nlsf_decode, smlawb, sqrt_approx};-use super::tables::*;+use super::tables::{+ NLSF_CB_NBMB, NLSF_CB_WB, NLSF_EXT, NLSF_PRED_NBMB, NLSF_PRED_WB, NLSF_PSEL_NBMB, NLSF_PSEL_WB, NLSF_SEL_NBMB, NLSF_SEL_WB, NLSF_STAGE1, NLSF_STAGE2,+};/// Number of stage-1 candidates refined with stage 2.const SURVIVORS: usize = 8;diff --git a/crates/opusenc/src/silk/pulses.rs b/crates/opusenc/src/silk/pulses.rsindex f8cda15a9..ba22b5ec5 100644--- a/crates/opusenc/src/silk/pulses.rs+++ b/crates/opusenc/src/silk/pulses.rs@@ -2,7 +2,7 @@//! with LSB escapes, the recursive shell code, LSBs and signs, written in exactly the order the//! decoder reads them.-use super::tables::*;+use super::tables::{EXC_LSB, EXC_SIGN, PULSE_COUNT, RATE_LEVEL, SHELL_2, SHELL_4, SHELL_8, SHELL_16};use crate::range::RangeEncoder;/// Largest pulse magnitude the quantiser produces (keeps every 16-sample block codable).