[nihav.git] / nihav-qt / src / codecs / alac.rs

use nihav_core::codecs::*;
use nihav_core::io::byteio::*;
use nihav_core::io::bitreader::*;
use nihav_core::io::intcode::*;
use std::str::FromStr;

struct ALACDecoder {
    ainfo:      NAAudioInfo,
    chmap:      NAChannelMap,
    bits:       u8,
    frame_len:  usize,
    samples_l:  Vec<i32>,
    samples_r:  Vec<i32>,
    cur_len:    usize,

    pb:         u8,
    kb:         u8,
    mb:         u8,
}

#[derive(Default,Clone,Copy)]
struct PredInfo {
    mode:       u8,
    shift:      u8,
    factor:     u8,
    order:      usize,
    filt:       [i32; 32],
}

fn read_code(br: &mut BitReader, k: u8, bits: u8) -> DecoderResult<u32> {
    let pfx                     = br.read_code(UintCodeType::LimitedUnary(9, 0))?;
    if pfx < 9 {
        if k > 1 {
            let tail            = br.read(k - 1)?;
            if tail != 0 {
                Ok((pfx << k) - pfx + tail * 2 + br.read(1)? - 1)
            } else {
                Ok((pfx << k) - pfx)
            }
        } else {
            Ok(pfx)
        }
    } else {
        Ok(br.read(bits)?)
    }
}

fn clip_sample(val: i32, bits: u8) -> i32 {
    val << (32 - bits) >> (32 - bits)
}

impl PredInfo {
    fn read_header(&mut self, br: &mut BitReader, pb: u8) -> DecoderResult<()> {
        self.mode               = br.read(4)? as u8;
        if self.mode != 0 && self.mode != 15 {
            return Err(DecoderError::NotImplemented);
        }
        self.shift              = br.read(4)? as u8;
        self.factor             = (br.read(3)? as u8) * pb / 4;
        self.order              = br.read(5)? as usize;
        for coef in self.filt.iter_mut().take(self.order).rev() {
            *coef               = br.read_s(16)?;
        }
        Ok(())
    }
    fn read_data(&mut self, br: &mut BitReader, dst: &mut [i32], kb: u8, mb: u8, bits: u8) -> DecoderResult<()> {
        let mut history = u32::from(mb);
        let mut add = 0;
        let dst_len = dst.len();
        let mut zero_run = 0;
        for (i, samp) in dst.iter_mut().enumerate() {
            if zero_run > 0 {
                *samp = 0;
                zero_run -= 1;
                continue;
            }
            let k = ((31 - ((history >> 9) + 3).leading_zeros()) as u8).min(kb);

            let val = read_code(br, k, bits)? + add;
            add = 0;
            *samp = if (val & 1) == 0 { val as i32 >> 1 } else { -(val as i32 >> 1) - 1 };

            if val > 0xFFFF {
                history = 0xFFFF;
            } else {
                history -= (history * u32::from(self.factor)) >> 9;
                history += val * u32::from(self.factor)
            }

            if history < 128 && (i + 1 < dst_len) {
                let k = (((history as u8).leading_zeros() as u8) + (((history + 16) >> 6) as u8)).min(kb);
                zero_run = read_code(br, k, 16)?;
                if zero_run < 0x10000 {
                    add = 1;
                }
                history = 0;
            }
        }
        Ok(())
    }
    #[allow(clippy::comparison_chain)]
    fn lpc_pred(&mut self, samps: &mut [i32], bits: u8) {
        if self.mode == 15 || self.order == 31 {
            for i in 1..samps.len() {
                samps[i] = clip_sample(samps[i].wrapping_add(samps[i - 1]), bits);
            }
        }
        if self.order == 0 {
            return;
        }
        for i in 0..self.order {
            samps[i + 1] = clip_sample(samps[i + 1].wrapping_add(samps[i]), bits);
        }
        for i in self.order+1..samps.len() {
            let mut diff = samps[i];

            let el0 = samps[i - self.order - 1];
            let mut sum = 0i32;
            for j in 0..self.order {
                sum = sum.wrapping_add((samps[i - self.order + j] - el0).wrapping_mul(self.filt[j]));
            }
            sum = (sum + ((1 << self.shift) >> 1)) >> self.shift;
            samps[i] = clip_sample(samps[i].wrapping_add(el0).wrapping_add(sum), bits);

            if diff != 0 {
                let sign = if diff > 0 { 1 } else { -1 };
                for j in 0..self.order {
                    if diff * sign <= 0 {
                        break;
                    }
                    let cur_diff = el0 - samps[i - self.order + j];
                    let dsign = if cur_diff > 0 { 1 } else if cur_diff < 0 { -1 } else { 0 } * sign;
                    self.filt[j] -= dsign;
                    diff -= ((cur_diff * dsign) >> self.shift) * ((j + 1) as i32);
                }
            }
        }
    }
}

impl ALACDecoder {
    fn new() -> Self {
        Self {
            ainfo:      NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 1),
            chmap:      NAChannelMap::new(),
            bits:       0,
            frame_len:  0,
            samples_l:  Vec::new(),
            samples_r:  Vec::new(),
            cur_len:    0,

            pb:         0,
            mb:         0,
            kb:         0,
        }
    }
    #[allow(clippy::collapsible_else_if)]
    fn decode_elem(&mut self, br: &mut BitReader, stereo: bool) -> DecoderResult<()> {
        let _element_instance           = br.read(4)?;
                                          br.skip(12)?;
        let partial                     = br.read_bool()?;
        let shift                       = (br.read(2)? * 8) as u8;
        let escape                      = br.read_bool()?;
        self.cur_len = if partial {
                                          br.read(32)? as usize
            } else { self.frame_len };

        if !escape {
            validate!(shift <= self.bits);
            let sbits = self.bits - shift + if stereo { 1 } else { 0 };
            let channels = if stereo { 2 } else { 1 };

            let mix_bits                = br.read(8)?;
            let mix_res                 = br.read_s(8)?;
            let mut pinfo = [PredInfo::default(); 2];
            for info in pinfo.iter_mut().take(channels) {
                info.read_header(br, self.pb)?;
            }
            let ebits_pos = br.tell() as u32;
                                          br.skip((shift as u32) * (self.cur_len as u32) * (channels as u32))?;
            pinfo[0].read_data(br, &mut self.samples_l[..self.cur_len], self.kb, self.mb, sbits)?;
            pinfo[0].lpc_pred(&mut self.samples_l[..self.cur_len], sbits);
            if stereo {
                pinfo[1].read_data(br, &mut self.samples_r[..self.cur_len], self.kb, self.mb, sbits)?;
                pinfo[1].lpc_pred(&mut self.samples_r[..self.cur_len], sbits);
            }
            if stereo && mix_res != 0 {
                let weight = mix_res;
                for (l, r) in self.samples_l[..self.cur_len].iter_mut().zip(self.samples_r[..self.cur_len].iter_mut()) {
                    let mut a = *l;
                    let b = *r;
                    a -= (b * weight) >> mix_bits;
                    *l = a + b;
                    *r = a;
                }
            }
            if shift > 0 {
                let end_pos = br.tell() as u32;
                br.seek(ebits_pos)?;
                for i in 0..self.cur_len {
                    self.samples_l[i] = (self.samples_l[i] << shift) | (br.read(shift)? as i32);
                    if stereo {
                        self.samples_r[i] = (self.samples_r[i] << shift) | (br.read(shift)? as i32);
                    }
                }
                br.seek(end_pos)?;
            }
        } else {
            if !stereo {
                for dst in self.samples_l.iter_mut().take(self.cur_len) {
                    *dst                = br.read_s(self.bits)? << shift;
                }
            } else {
                for (l, r) in self.samples_l.iter_mut().zip(self.samples_r.iter_mut()).take(self.cur_len) {
                    *l                  = br.read_s(self.bits)? << shift;
                    *r                  = br.read_s(self.bits)? << shift;
                }
            }
        }


        Ok(())
    }
    fn output_i16(&self, dst: &mut [i16], stride: usize, shift: u8, stereo: bool) {
        if !stereo {
            for (dst, &src) in dst[..self.frame_len].iter_mut().zip(self.samples_l.iter()) {
                *dst = (src << shift) as i16;
            }
        } else {
            let (l, r) = dst.split_at_mut(stride);
            for i in 0..self.frame_len {
                l[i] = (self.samples_l[i] << shift) as i16;
                r[i] = (self.samples_r[i] << shift) as i16;
            }
        }
    }
    fn output_i32(&self, dst: &mut [i32], stride: usize, shift: u8, stereo: bool) {
        if !stereo {
            for (dst, &src) in dst[..self.frame_len].iter_mut().zip(self.samples_l.iter()) {
                *dst = src << shift;
            }
        } else {
            let (l, r) = dst.split_at_mut(stride);
            for i in 0..self.frame_len {
                l[i] = self.samples_l[i] << shift;
                r[i] = self.samples_r[i] << shift;
            }
        }
    }
}

fn skip_dse(br: &mut BitReader) -> DecoderResult<()> {
                                          br.skip(4)?;
    let align                           = br.read_bool()?;
    let mut count                       = br.read(8)?;
    if count == 255 {
        count                          += br.read(8)?;
    }
    if align {
                                          br.align();
    }
                                          br.skip(count * 8)?;
    Ok(())
}

fn skip_fil(br: &mut BitReader) -> DecoderResult<()> {
    let mut count                       = br.read(4)?;
    if count == 15 {
        count                           = 14 + br.read(8)?;
    }
                                          br.skip(count * 8)?;
    Ok(())
}

impl NADecoder for ALACDecoder {
    fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
        if let (NACodecTypeInfo::Audio(_), Some(edata)) = (info.get_properties(), info.get_extradata()) {
            validate!(edata.len() >= 12 + 24);

            let mut mr = MemoryReader::new_read(&edata);
            let mut br = ByteReader::new(&mut mr);
            let len                         = br.read_u32be()? as usize;
            validate!(len == 12 + 24);
            let fcc                         = br.read_tag()?;
            validate!(&fcc == b"alac");
            let _flags                      = br.read_u32be()?;

            // config
            let frame_len                   = br.read_u32be()? as usize;
            let version                     = br.read_byte()?;
            validate!(version == 0);
            let bits                        = br.read_byte()?;
            validate!((8..=32).contains(&bits));
            self.pb                         = br.read_byte()?;
            validate!(self.pb == 40);
            self.mb                         = br.read_byte()?;
            validate!(self.mb == 10);
            self.kb                         = br.read_byte()?;
            validate!(self.kb == 14);
            let channels                    = br.read_byte()?;
            validate!(channels > 0);
            let max_run                     = br.read_u16be()?;
            validate!(max_run == 255);
            let _max_frame_bytes            = br.read_u32be()? as usize;
            let _avg_bitrate                = br.read_u32be()? as usize;
            let sample_rate                 = br.read_u32be()?;

            let mut chmap = match channels {
                    1 => "C",
                    2 => "L,R",
                    3 => "C,L,R",
                    4 => "C,L,R,Cs",
                    5 => "C,L,R,Ls,Rs",
                    6 => "C,L,R,Ls,Rs,LFE",
                    7 => "C,L,R,Ls,Rs,Cs,LFE",
                    8 => "C,Lc,Rc,L,R,Ls,Rs,LFE",
                    _ => return Err(DecoderError::NotImplemented),
                };
            if len + 24 <= edata.len() {
                let len2                    = br.read_u32be()? as usize;
                let id                      = br.read_tag()?;
                let _flags                  = br.read_u32be()?;
                if (len2 == 24) && (&id == b"chan") {
                    let layout              = br.read_u32be()?;
                    let _rsvd1              = br.read_u32be()?; // 0
                    let _rsvd2              = br.read_u32be()?; // 0
                    if (layout as u8) == channels {
                        chmap = match layout {
                                0x640001 => "C",
                                0x640002 => "L,R",
                                0x710003 => "C,L,R",
                                0x740004 => "C,L,R,Cs",
                                0x780005 => "C,L,R,Ls,Rs",
                                0x7C0006 => "C,L,R,Ls,Rs,LFE",
                                0x8E0007 => "C,L,R,Ls,Rs,Cs,LFE",
                                0x7F0008 => "C,Lc,Rc,L,R,Ls,Rs,LFE",
                                _        => return Err(DecoderError::NotImplemented),
                            };
                    }
                }
            }

            self.ainfo = NAAudioInfo::new(sample_rate, channels, if bits <= 16 { SND_S16P_FORMAT } else { SND_S32P_FORMAT }, frame_len);
            self.chmap = NAChannelMap::from_str(chmap).unwrap();
            self.bits = bits;
            self.frame_len = frame_len;
            self.samples_l = vec![0; frame_len];
            self.samples_r = vec![0; frame_len];

            Ok(())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
        let info = pkt.get_stream().get_info();
        if let NACodecTypeInfo::Audio(_) = info.get_properties() {
            let src = pkt.get_buffer();
            let channels = self.chmap.num_channels();
            let mut abuf = alloc_audio_buffer(self.ainfo, self.frame_len, self.chmap.clone())?;

            let mut br = BitReader::new(&src, BitReaderMode::BE);

            let mut channels_left = channels;
            if let Some(mut adata) = abuf.get_abuf_i16() {
                let shift = 16 - self.bits;
                let stride = adata.get_stride();
                let dst = adata.get_data_mut().unwrap();
                let mut off = 0;

                while br.left() >= 3 {
                    let tag             = br.read(3)?;
                    match tag {
                        0 | 3 => {
                            validate!(channels_left >= 1);
                            self.decode_elem(&mut br, false)?;
                            self.output_i16(&mut dst[off..], stride, shift, false);
                            off += stride;
                            channels_left -= 1;
                        },
                        1 => {
                            validate!(channels_left >= 2);
                            self.decode_elem(&mut br, true)?;
                            self.output_i16(&mut dst[off..], stride, shift, true);
                            off += stride * 2;
                            channels_left -= 2;
                        },
                        4 => skip_dse(&mut br)?,
                        6 => skip_fil(&mut br)?,
                        7 => break,
                        _ => return Err(DecoderError::InvalidData),
                    };
                }
            } else if let Some(mut adata) = abuf.get_abuf_i32() {
                let shift = 32 - self.bits;
                let stride = adata.get_stride();
                let dst = adata.get_data_mut().unwrap();
                let mut off = 0;

                while br.left() >= 3 {
                    let tag             = br.read(3)?;
                    match tag {
                        0 | 3 => {
                            validate!(channels_left >= 1);
                            self.decode_elem(&mut br, false)?;
                            self.output_i32(&mut dst[off..], stride, shift, false);
                            off += stride;
                            channels_left -= 1;
                        },
                        1 => {
                            validate!(channels_left >= 2);
                            self.decode_elem(&mut br, true)?;
                            self.output_i32(&mut dst[off..], stride, shift, true);
                            off += stride * 2;
                            channels_left -= 2;
                        },
                        4 => skip_dse(&mut br)?,
                        6 => skip_fil(&mut br)?,
                        7 => break,
                        _ => return Err(DecoderError::InvalidData),
                    };
                }
            } else {
                return Err(DecoderError::Bug);
            }
            abuf.truncate_audio(self.cur_len);

            let mut frm = NAFrame::new_from_pkt(pkt, info.replace_info(NACodecTypeInfo::Audio(self.ainfo)), abuf);
            frm.set_duration(Some(self.cur_len as u64));
            frm.set_keyframe(true);
            Ok(frm.into_ref())
        } else {
            Err(DecoderError::InvalidData)
        }
    }
    fn flush(&mut self) {
    }
}

impl NAOptionHandler for ALACDecoder {
    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(ALACDecoder::new())
}

#[cfg(test)]
mod test {
    use nihav_core::codecs::RegisteredDecoders;
    use nihav_core::demuxers::RegisteredDemuxers;
    use nihav_codec_support::test::dec_video::*;
    use crate::qt_register_all_decoders;
    use nihav_commonfmt::generic_register_all_demuxers;
    #[test]
    fn test_alac_16bit() {
        let mut dmx_reg = RegisteredDemuxers::new();
        generic_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        qt_register_all_decoders(&mut dec_reg);

        // sample: https://samples.mplayerhq.hu/A-codecs/lossless/luckynight.m4a
        test_decoding("mov", "alac", "assets/LLaudio/alac/luckynight.m4a", Some(48000 * 16), &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0x8b6562ac, 0x95981733, 0x47e14709, 0x45d4f05a]));
    }
    #[test]
    fn test_alac_6ch() {
        let mut dmx_reg = RegisteredDemuxers::new();
        generic_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        qt_register_all_decoders(&mut dec_reg);

        // sample: https://samples.mplayerhq.hu/A-codecs/lossless/ALAC/ALAC_6ch.mov
        test_decoding("mov", "alac", "assets/LLaudio/alac/ALAC_6ch.mov", None, &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0x0356ff3d, 0x1ddd3684, 0xb4da8b00, 0x8e8671a7]));
    }
    #[test]
    fn test_alac_24bit() {
        let mut dmx_reg = RegisteredDemuxers::new();
        generic_register_all_demuxers(&mut dmx_reg);
        let mut dec_reg = RegisteredDecoders::new();
        qt_register_all_decoders(&mut dec_reg);

        // sample: https://samples.mplayerhq.hu/A-codecs/lossless/ALAC/ALAC_24bits2.mov
        test_decoding("mov", "alac", "assets/LLaudio/alac/ALAC_24bits2.mov", None, &dmx_reg, &dec_reg,
                      ExpectedTestResult::MD5([0x15d58ed9, 0x9ee74f5e, 0x0fb82c0b, 0x27da35f9]));
    }
}
Commit	Line	Data
40494a85 KS	1	use nihav_core::codecs::*;
	2	use nihav_core::io::byteio::*;
	3	use nihav_core::io::bitreader::*;
	4	use nihav_core::io::intcode::*;
	5	use std::str::FromStr;
	6
	7	struct ALACDecoder {
	8	ainfo: NAAudioInfo,
	9	chmap: NAChannelMap,
	10	bits: u8,
	11	frame_len: usize,
	12	samples_l: Vec<i32>,
	13	samples_r: Vec<i32>,
	14	cur_len: usize,
	15
	16	pb: u8,
	17	kb: u8,
	18	mb: u8,
	19	}
	20
	21	#[derive(Default,Clone,Copy)]
	22	struct PredInfo {
	23	mode: u8,
	24	shift: u8,
	25	factor: u8,
	26	order: usize,
	27	filt: [i32; 32],
	28	}
	29
	30	fn read_code(br: &mut BitReader, k: u8, bits: u8) -> DecoderResult<u32> {
	31	let pfx = br.read_code(UintCodeType::LimitedUnary(9, 0))?;
	32	if pfx < 9 {
	33	if k > 1 {
	34	let tail = br.read(k - 1)?;
	35	if tail != 0 {
	36	Ok((pfx << k) - pfx + tail * 2 + br.read(1)? - 1)
	37	} else {
	38	Ok((pfx << k) - pfx)
	39	}
	40	} else {
	41	Ok(pfx)
	42	}
	43	} else {
	44	Ok(br.read(bits)?)
	45	}
	46	}
	47
	48	fn clip_sample(val: i32, bits: u8) -> i32 {
	49	val << (32 - bits) >> (32 - bits)
	50	}
	51
	52	impl PredInfo {
	53	fn read_header(&mut self, br: &mut BitReader, pb: u8) -> DecoderResult<()> {
	54	self.mode = br.read(4)? as u8;
	55	if self.mode != 0 && self.mode != 15 {
	56	return Err(DecoderError::NotImplemented);
	57	}
	58	self.shift = br.read(4)? as u8;
	59	self.factor = (br.read(3)? as u8) * pb / 4;
	60	self.order = br.read(5)? as usize;
	61	for coef in self.filt.iter_mut().take(self.order).rev() {
	62	*coef = br.read_s(16)?;
	63	}
	64	Ok(())
65	}
66	fn read_data(&mut self, br: &mut BitReader, dst: &mut [i32], kb: u8, mb: u8, bits: u8) -> DecoderResult<()> {
67	let mut history = u32::from(mb);
68	let mut add = 0;
69	let dst_len = dst.len();
70	let mut zero_run = 0;
71	for (i, samp) in dst.iter_mut().enumerate() {
72	if zero_run > 0 {
73	*samp = 0;
74	zero_run -= 1;
75	continue;
76	}
77	let k = ((31 - ((history >> 9) + 3).leading_zeros()) as u8).min(kb);
78
79	let val = read_code(br, k, bits)? + add;
80	add = 0;
81	*samp = if (val & 1) == 0 { val as i32 >> 1 } else { -(val as i32 >> 1) - 1 };
82
83	if val > 0xFFFF {
84	history = 0xFFFF;
85	} else {
86	history -= (history * u32::from(self.factor)) >> 9;
87	history += val * u32::from(self.factor)
88	}
89
90	if history < 128 && (i + 1 < dst_len) {
91	let k = (((history as u8).leading_zeros() as u8) + (((history + 16) >> 6) as u8)).min(kb);
92	zero_run = read_code(br, k, 16)?;
93	if zero_run < 0x10000 {
94	add = 1;
95	}
96	history = 0;
97	}
98	}
99	Ok(())
100	}
27116a4c	101	#[allow(clippy::comparison_chain)]
40494a85 KS	102	fn lpc_pred(&mut self, samps: &mut [i32], bits: u8) {
	103	if self.mode == 15 \|\| self.order == 31 {
	104	for i in 1..samps.len() {
	105	samps[i] = clip_sample(samps[i].wrapping_add(samps[i - 1]), bits);
	106	}
	107	}
	108	if self.order == 0 {
	109	return;
	110	}
	111	for i in 0..self.order {
	112	samps[i + 1] = clip_sample(samps[i + 1].wrapping_add(samps[i]), bits);
	113	}
	114	for i in self.order+1..samps.len() {
	115	let mut diff = samps[i];
	116
	117	let el0 = samps[i - self.order - 1];
	118	let mut sum = 0i32;
	119	for j in 0..self.order {
	120	sum = sum.wrapping_add((samps[i - self.order + j] - el0).wrapping_mul(self.filt[j]));
	121	}
	122	sum = (sum + ((1 << self.shift) >> 1)) >> self.shift;
	123	samps[i] = clip_sample(samps[i].wrapping_add(el0).wrapping_add(sum), bits);
	124
	125	if diff != 0 {
	126	let sign = if diff > 0 { 1 } else { -1 };
	127	for j in 0..self.order {
	128	if diff * sign <= 0 {
	129	break;
	130	}
	131	let cur_diff = el0 - samps[i - self.order + j];
	132	let dsign = if cur_diff > 0 { 1 } else if cur_diff < 0 { -1 } else { 0 } * sign;
	133	self.filt[j] -= dsign;
	134	diff -= ((cur_diff * dsign) >> self.shift) * ((j + 1) as i32);
	135	}
	136	}
	137	}
	138	}
	139	}
	140
	141	impl ALACDecoder {
	142	fn new() -> Self {
	143	Self {
	144	ainfo: NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 1),
	145	chmap: NAChannelMap::new(),
	146	bits: 0,
	147	frame_len: 0,
	148	samples_l: Vec::new(),
	149	samples_r: Vec::new(),
	150	cur_len: 0,
	151
	152	pb: 0,
	153	mb: 0,
	154	kb: 0,
	155	}
	156	}
27116a4c	157	#[allow(clippy::collapsible_else_if)]
40494a85 KS	158	fn decode_elem(&mut self, br: &mut BitReader, stereo: bool) -> DecoderResult<()> {
	159	let _element_instance = br.read(4)?;
	160	br.skip(12)?;
	161	let partial = br.read_bool()?;
	162	let shift = (br.read(2)? * 8) as u8;
	163	let escape = br.read_bool()?;
	164	self.cur_len = if partial {
	165	br.read(32)? as usize
	166	} else { self.frame_len };
	167
	168	if !escape {
	169	validate!(shift <= self.bits);
	170	let sbits = self.bits - shift + if stereo { 1 } else { 0 };
	171	let channels = if stereo { 2 } else { 1 };
	172
	173	let mix_bits = br.read(8)?;
	174	let mix_res = br.read_s(8)?;
	175	let mut pinfo = [PredInfo::default(); 2];
	176	for info in pinfo.iter_mut().take(channels) {
	177	info.read_header(br, self.pb)?;
	178	}
	179	let ebits_pos = br.tell() as u32;
	180	br.skip((shift as u32) * (self.cur_len as u32) * (channels as u32))?;
	181	pinfo[0].read_data(br, &mut self.samples_l[..self.cur_len], self.kb, self.mb, sbits)?;
	182	pinfo[0].lpc_pred(&mut self.samples_l[..self.cur_len], sbits);
	183	if stereo {
	184	pinfo[1].read_data(br, &mut self.samples_r[..self.cur_len], self.kb, self.mb, sbits)?;
	185	pinfo[1].lpc_pred(&mut self.samples_r[..self.cur_len], sbits);
	186	}
	187	if stereo && mix_res != 0 {
	188	let weight = mix_res;
	189	for (l, r) in self.samples_l[..self.cur_len].iter_mut().zip(self.samples_r[..self.cur_len].iter_mut()) {
	190	let mut a = *l;
	191	let b = *r;
	192	a -= (b * weight) >> mix_bits;
	193	*l = a + b;
	194	*r = a;
	195	}
	196	}
	197	if shift > 0 {
	198	let end_pos = br.tell() as u32;
	199	br.seek(ebits_pos)?;
	200	for i in 0..self.cur_len {
	201	self.samples_l[i] = (self.samples_l[i] << shift) \| (br.read(shift)? as i32);
	202	if stereo {
	203	self.samples_r[i] = (self.samples_r[i] << shift) \| (br.read(shift)? as i32);
	204	}
	205	}
	206	br.seek(end_pos)?;
	207	}
	208	} else {
	209	if !stereo {
	210	for dst in self.samples_l.iter_mut().take(self.cur_len) {
	211	*dst = br.read_s(self.bits)? << shift;
	212	}
	213	} else {
	214	for (l, r) in self.samples_l.iter_mut().zip(self.samples_r.iter_mut()).take(self.cur_len) {
	215	*l = br.read_s(self.bits)? << shift;
	216	*r = br.read_s(self.bits)? << shift;
	217	}
	218	}
	219	}
	220
	221
222	Ok(())
223	}
224	fn output_i16(&self, dst: &mut [i16], stride: usize, shift: u8, stereo: bool) {
225	if !stereo {
226	for (dst, &src) in dst[..self.frame_len].iter_mut().zip(self.samples_l.iter()) {
227	*dst = (src << shift) as i16;
228	}
229	} else {
230	let (l, r) = dst.split_at_mut(stride);
231	for i in 0..self.frame_len {
232	l[i] = (self.samples_l[i] << shift) as i16;
233	r[i] = (self.samples_r[i] << shift) as i16;
234	}
235	}
236	}
237	fn output_i32(&self, dst: &mut [i32], stride: usize, shift: u8, stereo: bool) {
238	if !stereo {
239	for (dst, &src) in dst[..self.frame_len].iter_mut().zip(self.samples_l.iter()) {
240	*dst = src << shift;
241	}
242	} else {
243	let (l, r) = dst.split_at_mut(stride);
244	for i in 0..self.frame_len {
245	l[i] = self.samples_l[i] << shift;
246	r[i] = self.samples_r[i] << shift;
247	}
248	}
249	}
250	}
251
252	fn skip_dse(br: &mut BitReader) -> DecoderResult<()> {
253	br.skip(4)?;
254	let align = br.read_bool()?;
255	let mut count = br.read(8)?;
256	if count == 255 {
257	count += br.read(8)?;
258	}
259	if align {
260	br.align();
261	}
262	br.skip(count * 8)?;
263	Ok(())
264	}
265
266	fn skip_fil(br: &mut BitReader) -> DecoderResult<()> {
267	let mut count = br.read(4)?;
268	if count == 15 {
269	count = 14 + br.read(8)?;
270	}
271	br.skip(count * 8)?;
272	Ok(())
273	}
274
275	impl NADecoder for ALACDecoder {
276	fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
277	if let (NACodecTypeInfo::Audio(_), Some(edata)) = (info.get_properties(), info.get_extradata()) {
278	validate!(edata.len() >= 12 + 24);
279
280	let mut mr = MemoryReader::new_read(&edata);
281	let mut br = ByteReader::new(&mut mr);
282	let len = br.read_u32be()? as usize;
283	validate!(len == 12 + 24);
284	let fcc = br.read_tag()?;
285	validate!(&fcc == b"alac");
286	let _flags = br.read_u32be()?;
287
288	// config
289	let frame_len = br.read_u32be()? as usize;
290	let version = br.read_byte()?;
291	validate!(version == 0);
292	let bits = br.read_byte()?;
6f263099	293	validate!((8..=32).contains(&bits));
40494a85 KS	294	self.pb = br.read_byte()?;
	295	validate!(self.pb == 40);
	296	self.mb = br.read_byte()?;
	297	validate!(self.mb == 10);
	298	self.kb = br.read_byte()?;
	299	validate!(self.kb == 14);
	300	let channels = br.read_byte()?;
	301	validate!(channels > 0);
	302	let max_run = br.read_u16be()?;
	303	validate!(max_run == 255);
	304	let _max_frame_bytes = br.read_u32be()? as usize;
	305	let _avg_bitrate = br.read_u32be()? as usize;
	306	let sample_rate = br.read_u32be()?;
	307
	308	let mut chmap = match channels {
	309	1 => "C",
	310	2 => "L,R",
	311	3 => "C,L,R",
	312	4 => "C,L,R,Cs",
	313	5 => "C,L,R,Ls,Rs",
	314	6 => "C,L,R,Ls,Rs,LFE",
	315	7 => "C,L,R,Ls,Rs,Cs,LFE",
	316	8 => "C,Lc,Rc,L,R,Ls,Rs,LFE",
	317	_ => return Err(DecoderError::NotImplemented),
	318	};
	319	if len + 24 <= edata.len() {
	320	let len2 = br.read_u32be()? as usize;
	321	let id = br.read_tag()?;
	322	let _flags = br.read_u32be()?;
	323	if (len2 == 24) && (&id == b"chan") {
	324	let layout = br.read_u32be()?;
	325	let _rsvd1 = br.read_u32be()?; // 0
	326	let _rsvd2 = br.read_u32be()?; // 0
	327	if (layout as u8) == channels {
	328	chmap = match layout {
	329	0x640001 => "C",
	330	0x640002 => "L,R",
	331	0x710003 => "C,L,R",
	332	0x740004 => "C,L,R,Cs",
	333	0x780005 => "C,L,R,Ls,Rs",
	334	0x7C0006 => "C,L,R,Ls,Rs,LFE",
	335	0x8E0007 => "C,L,R,Ls,Rs,Cs,LFE",
	336	0x7F0008 => "C,Lc,Rc,L,R,Ls,Rs,LFE",
	337	_ => return Err(DecoderError::NotImplemented),
	338	};
	339	}
	340	}
	341	}
	342
	343	self.ainfo = NAAudioInfo::new(sample_rate, channels, if bits <= 16 { SND_S16P_FORMAT } else { SND_S32P_FORMAT }, frame_len);
	344	self.chmap = NAChannelMap::from_str(chmap).unwrap();
	345	self.bits = bits;
	346	self.frame_len = frame_len;
	347	self.samples_l = vec![0; frame_len];
	348	self.samples_r = vec![0; frame_len];
	349
	350	Ok(())
	351	} else {
	352	Err(DecoderError::InvalidData)
	353	}
	354	}
	355	fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
	356	let info = pkt.get_stream().get_info();
	357	if let NACodecTypeInfo::Audio(_) = info.get_properties() {
358	let src = pkt.get_buffer();
359	let channels = self.chmap.num_channels();
2d1e0773	360	let mut abuf = alloc_audio_buffer(self.ainfo, self.frame_len, self.chmap.clone())?;
40494a85 KS	361
	362	let mut br = BitReader::new(&src, BitReaderMode::BE);
	363
	364	let mut channels_left = channels;
	365	if let Some(mut adata) = abuf.get_abuf_i16() {
	366	let shift = 16 - self.bits;
	367	let stride = adata.get_stride();
	368	let dst = adata.get_data_mut().unwrap();
	369	let mut off = 0;
	370
	371	while br.left() >= 3 {
	372	let tag = br.read(3)?;
	373	match tag {
	374	0 \| 3 => {
	375	validate!(channels_left >= 1);
	376	self.decode_elem(&mut br, false)?;
	377	self.output_i16(&mut dst[off..], stride, shift, false);
	378	off += stride;
	379	channels_left -= 1;
	380	},
	381	1 => {
	382	validate!(channels_left >= 2);
	383	self.decode_elem(&mut br, true)?;
	384	self.output_i16(&mut dst[off..], stride, shift, true);
	385	off += stride * 2;
	386	channels_left -= 2;
	387	},
	388	4 => skip_dse(&mut br)?,
	389	6 => skip_fil(&mut br)?,
	390	7 => break,
	391	_ => return Err(DecoderError::InvalidData),
	392	};
	393	}
40494a85 KS	394	} else if let Some(mut adata) = abuf.get_abuf_i32() {
	395	let shift = 32 - self.bits;
	396	let stride = adata.get_stride();
	397	let dst = adata.get_data_mut().unwrap();
	398	let mut off = 0;
	399
	400	while br.left() >= 3 {
	401	let tag = br.read(3)?;
	402	match tag {
	403	0 \| 3 => {
	404	validate!(channels_left >= 1);
	405	self.decode_elem(&mut br, false)?;
	406	self.output_i32(&mut dst[off..], stride, shift, false);
	407	off += stride;
	408	channels_left -= 1;
	409	},
	410	1 => {
	411	validate!(channels_left >= 2);
	412	self.decode_elem(&mut br, true)?;
	413	self.output_i32(&mut dst[off..], stride, shift, true);
	414	off += stride * 2;
	415	channels_left -= 2;
	416	},
	417	4 => skip_dse(&mut br)?,
	418	6 => skip_fil(&mut br)?,
	419	7 => break,
	420	_ => return Err(DecoderError::InvalidData),
	421	};
	422	}
40494a85 KS	423	} else {
	424	return Err(DecoderError::Bug);
	425	}
2d1e0773	426	abuf.truncate_audio(self.cur_len);
40494a85 KS	427
	428	let mut frm = NAFrame::new_from_pkt(pkt, info.replace_info(NACodecTypeInfo::Audio(self.ainfo)), abuf);
	429	frm.set_duration(Some(self.cur_len as u64));
	430	frm.set_keyframe(true);
	431	Ok(frm.into_ref())
	432	} else {
	433	Err(DecoderError::InvalidData)
	434	}
	435	}
	436	fn flush(&mut self) {
	437	}
	438	}
	439
	440	impl NAOptionHandler for ALACDecoder {
	441	fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
	442	fn set_options(&mut self, _options: &[NAOption]) { }
	443	fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
	444	}
	445
	446	pub fn get_decoder() -> Box<dyn NADecoder + Send> {
	447	Box::new(ALACDecoder::new())
	448	}
	449
	450	#[cfg(test)]
	451	mod test {
	452	use nihav_core::codecs::RegisteredDecoders;
	453	use nihav_core::demuxers::RegisteredDemuxers;
	454	use nihav_codec_support::test::dec_video::*;
	455	use crate::qt_register_all_decoders;
	456	use nihav_commonfmt::generic_register_all_demuxers;
	457	#[test]
	458	fn test_alac_16bit() {
	459	let mut dmx_reg = RegisteredDemuxers::new();
	460	generic_register_all_demuxers(&mut dmx_reg);
	461	let mut dec_reg = RegisteredDecoders::new();
	462	qt_register_all_decoders(&mut dec_reg);
	463
886cde48	464	// sample: https://samples.mplayerhq.hu/A-codecs/lossless/luckynight.m4a
40494a85 KS	465	test_decoding("mov", "alac", "assets/LLaudio/alac/luckynight.m4a", Some(48000 * 16), &dmx_reg, &dec_reg,
	466	ExpectedTestResult::MD5([0x8b6562ac, 0x95981733, 0x47e14709, 0x45d4f05a]));
	467	}
	468	#[test]
	469	fn test_alac_6ch() {
	470	let mut dmx_reg = RegisteredDemuxers::new();
	471	generic_register_all_demuxers(&mut dmx_reg);
	472	let mut dec_reg = RegisteredDecoders::new();
	473	qt_register_all_decoders(&mut dec_reg);
	474
886cde48	475	// sample: https://samples.mplayerhq.hu/A-codecs/lossless/ALAC/ALAC_6ch.mov
40494a85 KS	476	test_decoding("mov", "alac", "assets/LLaudio/alac/ALAC_6ch.mov", None, &dmx_reg, &dec_reg,
	477	ExpectedTestResult::MD5([0x0356ff3d, 0x1ddd3684, 0xb4da8b00, 0x8e8671a7]));
	478	}
	479	#[test]
	480	fn test_alac_24bit() {
	481	let mut dmx_reg = RegisteredDemuxers::new();
	482	generic_register_all_demuxers(&mut dmx_reg);
	483	let mut dec_reg = RegisteredDecoders::new();
	484	qt_register_all_decoders(&mut dec_reg);
	485
886cde48	486	// sample: https://samples.mplayerhq.hu/A-codecs/lossless/ALAC/ALAC_24bits2.mov
40494a85 KS	487	test_decoding("mov", "alac", "assets/LLaudio/alac/ALAC_24bits2.mov", None, &dmx_reg, &dec_reg,
	488	ExpectedTestResult::MD5([0x15d58ed9, 0x9ee74f5e, 0x0fb82c0b, 0x27da35f9]));
	489	}
	490	}