let max_energy = tgt_energy.max(fwd_energy).max(fwd_res_energy).max(bwd_energy).max(bwd_res_energy);
let scale = norm_bits(max_energy, 31);
- let tgt_energy = tgt_energy << scale >> 16;
+ let tgt_energy = tgt_energy << scale >> 16;
let fwd_energy = fwd_energy << scale >> 16;
let fwd_res_energy = fwd_res_energy << scale >> 16;
let bwd_energy = bwd_energy << scale >> 16;
fn compute_ppf_gains(&mut self, offset: usize, is_6300: bool, tgt_energy: i32, corr_energy: i32, res_energy: i32) {
self.ppf_index = offset;
- let tmp1 = tgt_energy * res_energy >> 1;
+ let tmp1 = (tgt_energy * res_energy) >> 1;
let tmp2 = corr_energy * corr_energy * 2;
if tmp1 >= tmp2 {
return;
self.ppf_opt_gain = if corr_energy >= res_energy {
gain_weight
} else {
- (corr_energy << 15) / res_energy * gain_weight >> 15
+ ((corr_energy << 15) / res_energy * gain_weight) >> 15
};
let tmp1 = (tgt_energy << 15) + (corr_energy * self.ppf_opt_gain * 2);
- let tmp2 = (self.ppf_opt_gain * self.ppf_opt_gain >> 15) * res_energy;
+ let tmp2 = ((self.ppf_opt_gain * self.ppf_opt_gain) >> 15) * res_energy;
let residual = tmp1.saturating_add(tmp2).saturating_add(1 << 15) >> 16;
self.ppf_sc_gain = square_root_i32(val << 16);
}
- self.ppf_opt_gain = i32::from(clip16(self.ppf_opt_gain * self.ppf_sc_gain >> 15));
+ self.ppf_opt_gain = i32::from(clip16((self.ppf_opt_gain * self.ppf_sc_gain) >> 15));
}
}
}
fn next_range(&mut self, range: usize) -> usize {
let val = (self.next() & 0x7FFF) as usize;
- val * range >> 15
+ (val * range) >> 15
}
}
br.read(1)?;
let mut ppos = br.read(13)? as usize;
self.subframe[0].pulse_pos = ppos / 810;
- ppos = ppos % 810;
+ ppos %= 810;
self.subframe[1].pulse_pos = ppos / 90;
- ppos = ppos % 90;
+ ppos %= 90;
self.subframe[2].pulse_pos = ppos / 9;
self.subframe[3].pulse_pos = ppos % 9;
Self::inverse_quant(&self.prev_lsp, &mut cur_lsp, &self.lsp_index, bad_frame);
Self::interpolate_lsp(&mut self.lpc, &cur_lsp, &self.prev_lsp);
self.prev_lsp.copy_from_slice(&cur_lsp);
- (&mut self.excitation[..MAX_PITCH]).copy_from_slice(&self.prev_excitation);
+ self.excitation[..MAX_PITCH].copy_from_slice(&self.prev_excitation);
if self.erased_frames == 0 {
let mut acb_vector = [0; SUBFRAME_LEN];
self.interp_gain = FIXED_CB_GAIN[(self.subframe[2].amp_index + self.subframe[3].amp_index) >> 1];
} else {
if self.interp_index != 0 {
for i in 0..self.interp_index {
- let sample = i32::from(self.excitation[MAX_PITCH + i]) * 3 >> 2;
+ let sample = (i32::from(self.excitation[MAX_PITCH + i]) * 3) >> 2;
self.synth_buf[LPC_ORDER + i] = sample as i16;
}
for i in self.interp_index..SAMPLES {
const CNG_BSEG: [i32; 3] = [ 2048, 18432, 231233 ];
let shift = 16 - cur_gain * 2;
let t = if shift > 0 { sid_gain << shift } else { sid_gain >> -shift };
- let x = t * 273 >> 16;
+ let x = (t * 273) >> 16;
if x >= CNG_BSEG[2] {
return 63;
}
}
}
- (&mut self.synth_buf[LPC_ORDER..][..MAX_PITCH]).copy_from_slice(&self.prev_excitation);
+ self.synth_buf[LPC_ORDER..][..MAX_PITCH].copy_from_slice(&self.prev_excitation);
let mut acb_vec = [0; SUBFRAME_LEN];
let mut tmp = [0; SUBFRAME_LEN * 2];
for i in (0..SUBFRAMES).step_by(2) {
let buf = &mut self.synth_buf[LPC_ORDER + SUBFRAME_LEN * i..];
self.subframe[i].gen_acb_excitation(&mut acb_vec, buf, self.is_6300);
- (&mut buf[..SUBFRAME_LEN]).copy_from_slice(&acb_vec);
+ buf[..SUBFRAME_LEN].copy_from_slice(&acb_vec);
self.subframe[i + 1].gen_acb_excitation(&mut acb_vec, &buf[SUBFRAME_LEN..], self.is_6300);
- (&mut buf[SUBFRAME_LEN..][..SUBFRAME_LEN]).copy_from_slice(&acb_vec);
+ buf[SUBFRAME_LEN..][..SUBFRAME_LEN].copy_from_slice(&acb_vec);
let mut max = 0;
for j in 0..SUBFRAME_LEN*2 {
}
b0 = ((i64::from(b0) * 2 * 2979 + (1 << 29)) >> 30) as i32;
- let mut c = self.cur_gain * (self.cur_gain * (SUBFRAME_LEN as i32) >> 5);
+ let mut c = self.cur_gain * ((self.cur_gain * (SUBFRAME_LEN as i32)) >> 5);
if shift * 2 + 3 >= 0 {
c >>= shift * 2 + 3;
} else {
c <<= -(shift * 2 + 3);
}
- c = (i64::from(clip32(sum * 2) - c) * 2979 >> 15) as i32;
+ c = ((i64::from(clip32(sum * 2) - c) * 2979) >> 15) as i32;
let delta = b0 * b0 * 2 - c;
let x = if delta <= 0 {
-b0
} else {
- let d0 = i32::from(square_root_i32(delta));
+ let d0 = square_root_i32(delta);
let x0 = d0 - b0;
let t = d0 + b0;
if t.abs() < x0.abs() {
let shift = shift + 1;
let x = (if shift >= 0 { x << shift } else { x >> -shift }).min(10000).max(-10000);
for j in 0..11 {
- let val = x * signs[i / 2][j] >> 15;
+ let val = (x * signs[i / 2][j]) >> 15;
buf[pos[i / 2 * 11 + j]] = buf[pos[i / 2 * 11 + j]].saturating_add(val as i16);
}
let best_energy = dot_product(&self.synth_buf[LPC_ORDER + MAX_PITCH + SUBFRAME_LEN * 2 - pos..], &self.synth_buf[LPC_ORDER + MAX_PITCH + SUBFRAME_LEN * 2 - pos..], SUBFRAME_LEN * 2);
let best_energy = best_energy.saturating_add(1 << 15) >> 16;
- let tmp = best_energy * self.sid_gain >> 3;
+ let tmp = (best_energy * self.sid_gain) >> 3;
if tmp < corr_energy * corr_energy {
self.interp_index = pos;
}
}
fn formant_postfilter(&mut self, dst: &mut [i16]) {
- (&mut self.synth_buf[..LPC_ORDER]).copy_from_slice(&self.fir_mem);
+ self.synth_buf[..LPC_ORDER].copy_from_slice(&self.fir_mem);
let mut filter_data = [0; LPC_ORDER + SAMPLES];
- (&mut filter_data[..LPC_ORDER]).copy_from_slice(&self.iir_mem);
+ filter_data[..LPC_ORDER].copy_from_slice(&self.iir_mem);
let mut filter_coef = [[0; LPC_ORDER]; 2];
for i in 0..SUBFRAMES {
let mut bad_frame = false;
let mut br = BitReader::new(src.as_slice(), BitReaderMode::LE);
- if let Err(_) = self.unpack_frame(&mut br) {
+ if self.unpack_frame(&mut br).is_err() {
bad_frame = true;
self.cur_ftype = if self.prev_ftype == G7231FrameType::Active {
G7231FrameType::Active
let abuf = alloc_audio_buffer(self.ainfo, SAMPLES, self.chmap.clone())?;
let mut adata = abuf.get_abuf_i16().unwrap();
- let mut asamples = adata.get_data_mut().unwrap();
+ let asamples = adata.get_data_mut().unwrap();
if self.cur_ftype == G7231FrameType::Active {
- self.synth_frame_active(&mut asamples, bad_frame);
+ self.synth_frame_active(asamples, bad_frame);
} else {
self.synth_frame_other();
}
self.prev_ftype = self.cur_ftype;
- (&mut self.synth_buf[..LPC_ORDER]).copy_from_slice(&self.filt_mem);
+ self.synth_buf[..LPC_ORDER].copy_from_slice(&self.filt_mem);
for i in 0..SUBFRAMES {
Self::do_lpc(&mut self.synth_buf, LPC_ORDER + i * SUBFRAME_LEN, &self.lpc[i]);
}
}
}
+impl NAOptionHandler for G7231Decoder {
+ fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
+ fn set_options(&mut self, _options: &[NAOption]) { }
+ fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
+}
+
pub fn get_decoder() -> Box<dyn NADecoder + Send> {
Box::new(G7231Decoder::new())
}
use nihav_core::codecs::RegisteredDecoders;
use nihav_core::demuxers::RegisteredDemuxers;
use nihav_codec_support::test::dec_video::*;
- use crate::vivo_register_all_codecs;
+ use crate::vivo_register_all_decoders;
use crate::vivo_register_all_demuxers;
#[test]
fn test_g723_1() {
let mut dmx_reg = RegisteredDemuxers::new();
vivo_register_all_demuxers(&mut dmx_reg);
let mut dec_reg = RegisteredDecoders::new();
- vivo_register_all_codecs(&mut dec_reg);
+ vivo_register_all_decoders(&mut dec_reg);
+ // sample: https://samples.mplayerhq.hu/vivo/viv1/adalogo.viv
let file = "assets/Misc/adalogo.viv";
//let file = "assets/Misc/gr_al.viv";
//test_decode_audio("vivo", file, Some(1500), None/*Some("g7231")*/, &dmx_reg, &dec_reg);