-use std::rc::Rc;
-use std::cell::RefCell;
use nihav_core::formats::*;
use nihav_core::frame::*;
use nihav_core::codecs::*;
use nihav_core::io::bitreader::*;
use nihav_core::io::byteio::*;
use nihav_core::io::codebook::*;
-use nihav_core::dsp::fft::FFTMode;
-use nihav_core::dsp::mdct::IMDCT;
+use nihav_codec_support::dsp::mdct::IMDCT;
use std::f32::consts;
#[derive(Clone,Copy,PartialEq)]
}
fn synth(&mut self, dsp: &mut DSP) {
let mut flag = 0;
- let mut band = 0;
- for (data, delay) in self.data.chunks_mut(256).zip(self.delay.chunks_mut(256)) {
+ for (band, (data, delay)) in self.data.chunks_mut(256).zip(self.delay.chunks_mut(256)).enumerate() {
if (flag & 1) != 0 {
for i in 0..128 {
let t0 = data[i];
dsp.apply_gains(data, delay, &mut self.gain_data, self.block_no, band);
delay.copy_from_slice(&dsp.tmp[256..512]);
flag ^= 1;
- band += 1;
}
self.block_no ^= 1;
}
fn read_coeffs_mode0(br: &mut BitReader, dst: &mut [f32], quant: usize, scale: f32) -> DecoderResult<()> {
let bits = ATRAC3_MODE0_BITS[quant];
if bits > 0 {
- for i in 0..dst.len() {
+ for el in dst.iter_mut() {
let val = br.read_s(bits)? as f32;
- dst[i] = val * scale;
+ *el = val * scale;
}
} else {
- for i in (0..dst.len()).step_by(2) {
+ for out in dst.chunks_mut(2) {
let val = br.read(4)? as usize;
- dst[i + 0] = ATRAC3_MODE0_CB[val >> 2] * scale;
- dst[i + 1] = ATRAC3_MODE0_CB[val & 3] * scale;
+ out[0] = ATRAC3_MODE0_CB[val >> 2] * scale;
+ out[1] = ATRAC3_MODE0_CB[val & 3] * scale;
}
}
Ok(())
];
fn read_coeffs_mode1(br: &mut BitReader, cb: &Codebook<u8>, dst: &mut [f32], scale: f32) -> DecoderResult<()> {
- for i in (0..dst.len()).step_by(2) {
+ for out in dst.chunks_mut(2) {
let val = br.read_cb(cb)? as usize;
- dst[i + 0] = ATRAC3_MODE1_CB[val * 2 + 0] * scale;
- dst[i + 1] = ATRAC3_MODE1_CB[val * 2 + 1] * scale;
+ out[0] = ATRAC3_MODE1_CB[val * 2 + 0] * scale;
+ out[1] = ATRAC3_MODE1_CB[val * 2 + 1] * scale;
}
Ok(())
}
fn read_coeffs_other(br: &mut BitReader, cb: &Codebook<u8>, dst: &mut [f32], scale: f32) -> DecoderResult<()> {
- for i in 0..dst.len() {
+ for el in dst.iter_mut() {
let val = (br.read_cb(cb)? as i8) + 1;
let sign = (val & 1) != 0;
- let coef = (if sign { -(val >> 1) } else { val >> 1 }) as f32;
- dst[i] = coef * scale;
+ let coef = f32::from(if sign { -(val >> 1) } else { val >> 1 });
+ *el = coef * scale;
}
Ok(())
}
tmp: [f32; ATRAC3_FRAME_SIZE + 64],
}
+#[allow(clippy::manual_memcpy)]
impl DSP {
fn new() -> Self {
let mut gain_tab: [f32; 16] = [0.0; 16];
}
Self {
- imdct: IMDCT::new(FFTMode::SplitRadix, 512, false),
+ imdct: IMDCT::new(512, false),
tmp: [0.0; ATRAC3_FRAME_SIZE + 64],
gain_tab, gain_tab2, window,
}
}
struct Atrac3Decoder {
- info: Rc<NACodecInfo>,
+ info: NACodecInfoRef,
channels: usize,
chmap: NAChannelMap,
samples: usize,
}
impl CodebookDescReader<u8> for Atrac3CodebookReader {
fn bits(&mut self, idx: usize) -> u8 { self.bits[idx] }
- fn code(&mut self, idx: usize) -> u32 { self.codes[idx] as u32 }
+ fn code(&mut self, idx: usize) -> u32 { u32::from(self.codes[idx]) }
fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
fn len(&mut self) -> usize { self.bits.len() }
}
scalefactors,
}
}
+ #[allow(clippy::identity_op)]
fn rev_matrix(&mut self) {
for i in 0..4 {
let c0 = self.mci_prev[i];
if self.weighting_delay[1] == 7 {
pw = [1.0; 2];
} else {
- let w = (self.weighting_delay[1] as f32) / 7.0;
+ let w = f32::from(self.weighting_delay[1]) / 7.0;
let iw = (2.0 - w * w).sqrt();
if self.weighting_delay[0] == 0 {
pw = [w, iw];
if self.weighting_delay[3] == 7 {
cw = [1.0; 2];
} else {
- let w = (self.weighting_delay[3] as f32) / 7.0;
+ let w = f32::from(self.weighting_delay[3]) / 7.0;
let iw = (2.0 - w * w).sqrt();
if self.weighting_delay[2] == 0 {
cw = [w, iw];
}
impl NADecoder for Atrac3Decoder {
- fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
+ fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
self.info = info.clone();
let edata = info.get_extradata().unwrap();
Err(DecoderError::InvalidData)
}
}
- fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
+ fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
let info = pkt.get_stream().get_info();
validate!(info.get_properties().is_audio());
let pktbuf = pkt.get_buffer();
}
{
- let mut br = BitReader::new(self.pkt_buf.as_slice(), frame_size, BitReaderMode::BE);
+ let mut br = BitReader::new(&self.pkt_buf[0..frame_size], BitReaderMode::BE);
let id = br.read(6)?;
validate!(id == 0x28);
self.ch_data[0].decode_unit(&mut br, &self.codebooks, &self.scalefactors)?;
} else {
off = frame_size / 2;
}
- let mut br = BitReader::new(&self.pkt_buf[off..], frame_size - off, BitReaderMode::BE);
+ let mut br = BitReader::new(&self.pkt_buf[off..frame_size], BitReaderMode::BE);
if self.mode == Mode::JointStereo {
let id = br.read(2)?;
validate!(id == 0x3);
let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
frm.set_keyframe(true);
- Ok(Rc::new(RefCell::new(frm)))
+ Ok(frm.into_ref())
}
+ fn flush(&mut self) {
+ for ch_data in self.ch_data.iter_mut() {
+ ch_data.delay = [0.0; 1024];
+ ch_data.qmf_delay = [0.0; 64 * 3];
+ }
+ }
+}
+
+impl NAOptionHandler for Atrac3Decoder {
+ 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<NADecoder> {
+pub fn get_decoder() -> Box<dyn NADecoder + Send> {
Box::new(Atrac3Decoder::new())
}
mod test {
use nihav_core::codecs::RegisteredDecoders;
use nihav_core::demuxers::RegisteredDemuxers;
- use nihav_core::test::dec_video::test_decode_audio;
- use crate::codecs::generic_register_all_codecs;
- use nihav_realmedia::demuxers::realmedia_register_all_demuxers;
+ use nihav_codec_support::test::dec_video::test_decode_audio;
+ use crate::generic_register_all_decoders;
+ use nihav_realmedia::realmedia_register_all_demuxers;
#[test]
fn test_atrac3() {
let mut dmx_reg = RegisteredDemuxers::new();
realmedia_register_all_demuxers(&mut dmx_reg);
let mut dec_reg = RegisteredDecoders::new();
- generic_register_all_codecs(&mut dec_reg);
+ generic_register_all_decoders(&mut dec_reg);
let file = "assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm";
// let file = "assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm";
- test_decode_audio("realmedia", file, Some(12000), "atrac3", &dmx_reg, &dec_reg);
+ test_decode_audio("realmedia", file, Some(12000), None/*Some("atrac3")*/, &dmx_reg, &dec_reg);
}
}