nihav-qt/src/codecs/alac.rs

   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     }
 101     #[allow(clippy::comparison_chain)]
 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     }
 157     #[allow(clippy::collapsible_else_if)]
 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()?;
 293             validate!((8..=32).contains(&bits));
 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();
 360             let mut abuf = alloc_audio_buffer(self.ainfo, self.frame_len, self.chmap.clone())?;
 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                 }
 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                 }
 423             } else {
 424                 return Err(DecoderError::Bug);
 425             }
 426             abuf.truncate_audio(self.cur_len);
 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
 464         // sample: https://samples.mplayerhq.hu/A-codecs/lossless/luckynight.m4a
 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
 475         // sample: https://samples.mplayerhq.hu/A-codecs/lossless/ALAC/ALAC_6ch.mov
 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
 486         // sample: https://samples.mplayerhq.hu/A-codecs/lossless/ALAC/ALAC_24bits2.mov
 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 }