pub struct CeltAllocFlags {
  offsets : Array[Int]
  alloc_trim : Int
}

pub struct CeltAllocation {
  pulses : Array[Int]
  ebits : Array[Int]
  fine_priority : Array[Int]
  coded_bands : Int
  balance : Int
}

pub struct CeltDecoderState {
  old_e : Array[Double]
  old_log_e : Array[Double]
  old_log_e2 : Array[Double]
  rng : Int64
}

pub struct CeltFrameHeader {
  silence : Bool
  postfilter_on : Bool
  postfilter_pitch : Int
  postfilter_gain : Double
  postfilter_tapset : Int
  is_transient : Bool
  intra : Bool
}

pub struct CeltFrameResult {
  header : CeltFrameHeader
  spectrum : Array[Double]
  freq : Array[Double]
  collapse_masks : Array[Int]
  seed : Int64
}

pub struct CeltPartitionLeaf {
  n : Int
  blocks : Int
  lm : Int
  b : Int
  q : Int
  used : Int
  fill : Int
  pulses : Array[Int]
}

pub struct CeltPartitionResult {
  splits : Array[CeltThetaSplit]
  leaves : Array[CeltPartitionLeaf]
  remaining_bits : Int
}

pub struct CeltThetaSplit {
  inv : Int
  imid : Int
  iside : Int
  delta : Int
  itheta : Int
  qalloc : Int
  qn : Int
}

pub struct OggPage {
  data : Bytes
  offset : Int
  header_type : Int
  granule_position : Int64
  serial_number : UInt
  page_sequence : UInt
  checksum : UInt
  n_segments : Int
  body_len : Int
}

pub enum OpusBandwidth {
  Nb
  Mb
  Wb
  Swb
  Fb
}

type OpusHead

pub enum OpusMode {
  Silk
  Hybrid
  Celt
}

pub struct OpusPacket {
  config : Int
  stereo : Bool
  mode : OpusMode
  bandwidth : OpusBandwidth
  frame_samples : Int
  frame_count : Int
  frame_lengths : Array[Int]
  is_vbr : Bool
  padding_bytes : Int
}

pub struct OpusStream {
  head : OpusHead
  tags : OpusTags
  audio : Array[Bytes]
}

type OpusTags

type PacketAssembler

pub struct RangeDecoder {
  data : Bytes
  nbytes : Int
  offs : Int
  leftover : Int
  val : Int64
  rng : Int64
  raw_read : Int
  skipped : Int
}

let CEL_BITRES : Int

let CEL_COMB_MINPERIOD : Int

let CEL_DEEMPH_COEF : Double

let CEL_MAX_FINE_BITS : Int

let CEL_MAX_PSEUDO : Int

let CEL_NB_EBANDS : Int

let CEL_OVERLAP : Int

let CEL_SHORT_MDCT : Int

let FLAG_BOS : Int

let FLAG_CONTINUED : Int

let FLAG_EOS : Int

fn cel_unquant_coarse_energy(dec : RangeDecoder, old_e : Array[Double], start : Int, end : Int, intra : Bool, lm : Int) -> Unit

fn cel_unquant_energy_finalise(dec : RangeDecoder, old_e : Array[Double], start : Int, end : Int, fine_quant : Array[Int], fine_priority : Array[Int], bits_left : Int) -> Unit

fn cel_unquant_fine_energy(dec : RangeDecoder, old_e : Array[Double], start : Int, end : Int, extra_quant : Array[Int]) -> Unit

fn celt_alloc_total(frame_bytes : Int, dec : RangeDecoder) -> Int

fn celt_anti_collapse(x : Array[Double], collapse_masks : Array[Int], lm : Int, start : Int, end : Int, band_log_e : Array[Double], prev1_log_e : Array[Double], prev2_log_e : Array[Double], pulses : Array[Int], seed : Int64) -> Unit

fn celt_anti_collapse_rsv(is_transient : Bool, lm : Int, bits : Int) -> Int

fn celt_band_bins(i : Int, m : Int) -> Int

fn celt_bitexact_cos(x : Int) -> Int

fn celt_bitexact_log2tan(isin : Int, icos : Int) -> Int

fn celt_bits2pulses(band : Int, lm : Int, bits : Int) -> Int

fn celt_comb_filter(buf : Array[Double], base : Int, t0 : Int, t1 : Int, n : Int, g0 : Double, g1 : Double, ts0 : Int, ts1 : Int, win : Array[Double]) -> Unit

fn celt_compute_allocation(dec : RangeDecoder, start : Int, end : Int, offsets : Array[Int], cap : Array[Int], alloc_trim : Int, total : Int, lm : Int) -> CeltAllocation

fn celt_compute_qn(n : Int, b : Int, offset : Int, pulse_cap : Int, stereo : Bool) -> Int

fn celt_compute_theta(dec : RangeDecoder, band : Int, lm : Int, n : Int, b : Int, blocks : Int, blocks0 : Int, stereo : Bool, intensity : Int, remaining_bits : Int, disable_inv : Bool, fill : Int) -> (CeltThetaSplit, Int, Int)

fn celt_decode_alloc_flags(dec : RangeDecoder, start : Int, end : Int, cap : Array[Int], frame_bytes : Int, lm : Int) -> CeltAllocFlags

fn celt_decode_anti_collapse_flag(dec : RangeDecoder, rsv : Int) -> Int

fn celt_decode_frame(dec : RangeDecoder, frame_bytes : Int, start : Int, end : Int, lm : Int, state : CeltDecoderState) -> CeltFrameResult

fn celt_decode_frame_header(dec : RangeDecoder, frame_bytes : Int, start : Int, lm : Int) -> CeltFrameHeader

fn celt_decode_pulses(dec : RangeDecoder, n : Int, k : Int) -> Array[Int]

fn celt_decode_quant_partition(dec : RangeDecoder, band : Int, lm : Int, n : Int, b : Int, blocks : Int, fill : Int, remaining_bits : Int) -> CeltPartitionResult

fn celt_decode_spread(dec : RangeDecoder, frame_bytes : Int) -> Int

fn celt_decode_tf(dec : RangeDecoder, start : Int, end : Int, is_transient : Bool, lm : Int, frame_bytes : Int) -> Array[Int]

fn celt_deemphasis(input : Array[Double], out : Array[Double], mem : Double) -> Double

fn celt_denormalise(x : Array[Double], band_log_e : Array[Double], start : Int, end : Int, m : Int, silence : Bool) -> Array[Double]

fn celt_eband(i : Int, m : Int) -> Int

fn celt_exp_rotation(x : Array[Double], b : Int, k : Int, spread : Int) -> Unit

fn celt_get_pulses(i : Int) -> Int

fn celt_imdct_frame(freq : Array[Double], lm : Int, is_transient : Bool, pending : Array[Double]) -> (Array[Double], Array[Double])

fn celt_init_caps(lm : Int, channels : Int) -> Array[Int]

fn celt_isqrt32(v : Int) -> Int

fn celt_lcg_rand(seed : Int64) -> Int64

fn celt_lm_of_frame_samples(samples : Int) -> Int?

fn celt_max_bin(m : Int) -> Int

fn celt_pulses2bits(band : Int, lm : Int, pulses : Int) -> Int

fn celt_pvq_unindex(n : Int, k : Int, tab : Array[Int64], idx : Int64) -> Array[Int]

fn celt_pvq_v_table(n : Int, k : Int) -> Array[Int64]

fn celt_quant_all_bands(dec : RangeDecoder, x : Array[Double], start : Int, end : Int, lm : Int, short_blocks : Bool, pulses : Array[Int], tf_res : Array[Int], coded_bands : Int, total_bits : Int, balance : Int, spread : Int, seed : Int64, masks : Array[Int]) -> Int64

fn celt_quant_band(dec : RangeDecoder, x : Array[Double], lowband : Array[Double], band : Int, lm : Int, n : Int, b : Int, blocks : Int, tf_change : Int, fill : Int, gain : Double, spread : Int, seed : Int64, remaining : Int, lowband_out : Array[Double]) -> (Int, Int64, Int)

fn celt_renormalise_vector(x : Array[Double], off : Int, n : Int, gain : Double) -> Unit

fn celt_tf_forward(x : Array[Double], n : Int, b : Int, tf_change : Int) -> Unit

fn celt_tf_inverse(x : Array[Double], n : Int, b : Int, tf_change : Int) -> Unit

fn celt_window(i : Int, overlap : Int) -> Double

fn ogg_crc32(data : Bytes) -> UInt

fn ogg_crc32_update(crc : UInt, data : Bytes, start : Int, len : Int) -> UInt

fn open_opus(data : Bytes) -> Result[OpusStream, String]

fn parse_opus_packet(data : Bytes) -> Result[OpusPacket, String]