nihav-ms/src/codecs/msadpcm.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::byteio::*;
   3 use std::str::FromStr;
   4
   5 const ADAPT_TABLE: [i32; 16] = [
   6     230, 230, 230, 230, 307, 409, 512, 614,
   7     768, 614, 512, 409, 307, 230, 230, 230
   8 ];
   9 const ADAPT_COEFFS: [[i32; 2]; 7] = [
  10     [ 256, 0 ], [ 512, -256 ], [ 0, 0 ], [ 192, 64 ],
  11     [ 240, 0 ], [ 460, -208 ], [ 392, -232 ]
  12 ];
  13
  14 #[derive(Default)]
  15 struct Predictor {
  16     sample1:    i32,
  17     sample2:    i32,
  18     delta:      i32,
  19     coef1:      i32,
  20     coef2:      i32,
  21 }
  22
  23 impl Predictor {
  24     fn expand_nibble(&mut self, nibble: u8) -> i16 {
  25         let mul = if (nibble & 8) == 0 { i32::from(nibble) } else { i32::from(nibble) - 16 };
  26         let pred = self.calc_pred() + self.delta.wrapping_mul(mul);
  27         self.update(pred.max(-0x8000).min(0x7FFF));
  28         self.delta = (ADAPT_TABLE[nibble as usize].wrapping_mul(self.delta) >> 8).max(16);
  29         self.sample1 as i16
  30     }
  31     fn calc_pred(&self) -> i32 {
  32         self.sample1.wrapping_mul(self.coef1).wrapping_add(self.sample2.wrapping_mul(self.coef2)) >> 8
  33     }
  34     fn update(&mut self, new_samp: i32) {
  35         self.sample2 = self.sample1;
  36         self.sample1 = new_samp;
  37     }
  38 }
  39
  40 struct MSADPCMDecoder {
  41     ainfo:          NAAudioInfo,
  42     chmap:          NAChannelMap,
  43     adapt_coeffs:   Vec<[i32; 2]>,
  44     block_len:      usize,
  45     block_samps:    usize,
  46 }
  47
  48 impl MSADPCMDecoder {
  49     fn new() -> Self {
  50         Self {
  51             ainfo:          NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
  52             chmap:          NAChannelMap::new(),
  53             adapt_coeffs:   Vec::with_capacity(7),
  54             block_len:      0,
  55             block_samps:    0,
  56         }
  57     }
  58 }
  59
  60 impl NADecoder for MSADPCMDecoder {
  61     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
  62         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
  63             self.block_len = ainfo.get_block_len();
  64             let channels = ainfo.get_channels() as usize;
  65             validate!(channels == 2 || channels == 1);
  66             validate!(self.block_len >= 7 * channels + 1);
  67             self.block_samps = (self.block_len / channels - 7) * 2 + 2;
  68             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), channels as u8, SND_S16P_FORMAT, self.block_samps);
  69             self.chmap = NAChannelMap::from_str(if channels == 1 { "C" } else { "L,R" }).unwrap();
  70             self.adapt_coeffs.truncate(0);
  71             if let Some(ref buf) = info.get_extradata() {
  72                 validate!(buf.len() >= 6);
  73                 validate!((buf.len() & 3) == 0);
  74                 let mut mr = MemoryReader::new_read(buf.as_slice());
  75                 let mut br = ByteReader::new(&mut mr);
  76                 let _smth               = br.read_u16le()?;
  77                 let ncoeffs             = br.read_u16le()? as usize;
  78                 validate!(buf.len() == ncoeffs * 4 + 4);
  79
  80                 for _ in 0..ncoeffs {
  81                     let pair = [
  82                         i32::from(br.read_u16le()? as i16),
  83                         i32::from(br.read_u16le()? as i16)];
  84                     self.adapt_coeffs.push(pair);
  85                 }
  86             } else {
  87                 self.adapt_coeffs.extend_from_slice(&ADAPT_COEFFS);
  88             }
  89             Ok(())
  90         } else {
  91             Err(DecoderError::InvalidData)
  92         }
  93     }
  94     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
  95         let info = pkt.get_stream().get_info();
  96         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
  97             let pktbuf = pkt.get_buffer();
  98             let channels = self.chmap.num_channels();
  99             validate!(pktbuf.len() > 0 && (pktbuf.len() % self.block_len) == 0);
 100             let nblocks = pktbuf.len() / self.block_len;
 101             let nsamples = nblocks * self.block_samps;
 102             let abuf = alloc_audio_buffer(self.ainfo, nsamples, self.chmap.clone())?;
 103             let mut adata = abuf.get_abuf_i16().unwrap();
 104             let mut off = [adata.get_offset(0), adata.get_offset(1)];
 105             let dst = adata.get_data_mut().unwrap();
 106
 107             let mut pred = [Predictor::default(), Predictor::default()];
 108
 109             for blk in pktbuf.chunks(self.block_len) {
 110                 let mut mr = MemoryReader::new_read(blk);
 111                 let mut br = ByteReader::new(&mut mr);
 112                 for ch in 0..channels {
 113                     let coef_idx                = br.read_byte()? as usize;
 114                     validate!(coef_idx < self.adapt_coeffs.len());
 115                     pred[ch].coef1 = self.adapt_coeffs[coef_idx][0];
 116                     pred[ch].coef2 = self.adapt_coeffs[coef_idx][1];
 117                 }
 118                 for ch in 0..channels {
 119                     pred[ch].delta              = i32::from(br.read_u16le()?);
 120                 }
 121                 for ch in 0..channels {
 122                     let samp                    = br.read_u16le()? as i16;
 123                     pred[ch].sample2            = i32::from(samp);
 124                 }
 125                 for ch in 0..channels {
 126                     let samp                    = br.read_u16le()? as i16;
 127                     pred[ch].sample1            = i32::from(samp);
 128                 }
 129                 for ch in 0..channels {
 130                     dst[off[ch]]     = pred[ch].sample2 as i16;
 131                     dst[off[ch] + 1] = pred[ch].sample1 as i16;
 132                     off[ch] += 2;
 133                 }
 134                 if channels == 1 {
 135                     while br.left() > 0 {
 136                         let idx                 = br.read_byte()?;
 137                         dst[off[0]] = pred[0].expand_nibble(idx >> 4);
 138                         off[0] += 1;
 139                         dst[off[0]] = pred[0].expand_nibble(idx & 0xF);
 140                         off[0] += 1;
 141                     }
 142                 } else {
 143                     while br.left() > 0 {
 144                         let idx                 = br.read_byte()?;
 145                         dst[off[0]] = pred[0].expand_nibble(idx >> 4);
 146                         off[0] += 1;
 147                         dst[off[1]] = pred[1].expand_nibble(idx & 0xF);
 148                         off[1] += 1;
 149                     }
 150                 }
 151             }
 152             let mut frm = NAFrame::new_from_pkt(pkt, info.replace_info(NACodecTypeInfo::Audio(self.ainfo)), abuf);
 153             frm.set_duration(Some(nsamples as u64));
 154             frm.set_keyframe(false);
 155             Ok(frm.into_ref())
 156         } else {
 157             Err(DecoderError::InvalidData)
 158         }
 159     }
 160     fn flush(&mut self) {
 161     }
 162 }
 163
 164 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
 165     Box::new(MSADPCMDecoder::new())
 166 }
 167
 168 #[derive(Default)]
 169 struct MSADPCMEncoder {
 170     stream:     Option<NAStreamRef>,
 171     samples:    Vec<i16>,
 172     block_len:  usize,
 173     channels:   usize,
 174     flush:      bool,
 175     srate:      u32,
 176 }
 177
 178 const DEFAULT_BLOCK_LEN: usize = 256;
 179
 180 impl MSADPCMEncoder {
 181     fn new() -> Self { Self::default() }
 182     fn encode_packet(&mut self) -> EncoderResult<NAPacket> {
 183         if self.samples.len() == 0 {
 184             return Err(EncoderError::TryAgain);
 185         }
 186         let len = (self.samples.len() / self.channels).min(self.block_len);
 187         if len < self.block_len && !self.flush {
 188             return Err(EncoderError::TryAgain);
 189         }
 190         if len < 2 {
 191             self.flush = false;
 192             return Err(EncoderError::TryAgain);
 193         }
 194
 195         let mut dbuf = vec![0u8; Self::calc_block_size(len, self.channels)];
 196         let mut mw = MemoryWriter::new_write(dbuf.as_mut_slice());
 197         let mut bw = ByteWriter::new(&mut mw);
 198
 199         let mut best_idx = [0usize; 2];
 200         for ch in 0..self.channels {
 201             let mut best_dist = std::i64::MAX;
 202             for i in 0..ADAPT_COEFFS.len() {
 203                 let dist = self.calc_dist(ch, i, len);
 204                 if dist < best_dist {
 205                     best_dist = dist;
 206                     best_idx[ch] = i;
 207                 }
 208             }
 209             bw.write_byte(best_idx[ch] as u8)?;
 210         }
 211         let mut dec = [Predictor::default(), Predictor::default()];
 212         for ch in 0..self.channels {
 213             dec[ch].sample1 = i32::from(self.samples[ch + self.channels]);
 214             dec[ch].sample2 = i32::from(self.samples[ch]);
 215             dec[ch].coef1   = ADAPT_COEFFS[best_idx[ch]][0];
 216             dec[ch].coef2   = ADAPT_COEFFS[best_idx[ch]][1];
 217             if len > 2 {
 218                 let pred = dec[ch].calc_pred();
 219                 dec[ch].delta = ((i32::from(self.samples[ch + self.channels * 2]) - pred).abs() / 4).max(16);
 220             } else {
 221                 dec[ch].delta = 16;
 222             }
 223         }
 224         for ch in 0..self.channels {
 225             bw.write_u16le(dec[ch].delta as u16)?;
 226         }
 227         for ch in 0..self.channels {
 228             bw.write_u16le(dec[ch].sample1 as u16)?;
 229         }
 230         for ch in 0..self.channels {
 231             bw.write_u16le(dec[ch].sample2 as u16)?;
 232         }
 233         if self.channels == 1 {
 234             for samps in self.samples.chunks(2).skip(1).take(len/2 - 1) {
 235                 let diff = i32::from(samps[0]) - dec[0].calc_pred();
 236                 let nib0 = Self::calculate_mul(dec[0].delta, diff);
 237                 dec[0].expand_nibble(nib0);
 238                 let diff = i32::from(samps[1]) - dec[0].calc_pred();
 239                 let nib1 = Self::calculate_mul(dec[0].delta, diff);
 240                 dec[0].expand_nibble(nib1);
 241                 bw.write_byte(nib0 * 16 + nib1)?;
 242             }
 243         } else {
 244             for samps in self.samples.chunks(2).skip(2).take(len - 2) {
 245                 let diff = i32::from(samps[0]) - dec[0].calc_pred();
 246                 let nib0 = Self::calculate_mul(dec[0].delta, diff);
 247                 dec[0].expand_nibble(nib0);
 248                 let diff = i32::from(samps[1]) - dec[1].calc_pred();
 249                 let nib1 = Self::calculate_mul(dec[1].delta, diff);
 250                 dec[1].expand_nibble(nib1);
 251                 bw.write_byte(nib0 * 16 + nib1)?;
 252             }
 253         }
 254         self.samples.drain(..len * self.channels);
 255         drop(bw);
 256         let ts = NATimeInfo::new(None, None, Some(1), 1, self.srate);
 257         Ok(NAPacket::new(self.stream.clone().unwrap(), ts, true, dbuf))
 258     }
 259     fn calc_dist(&self, ch: usize, idx: usize, len: usize) -> i64 {
 260         let mut dist = 0;
 261         let mut dec = Predictor {
 262                 sample2: i32::from(self.samples[ch]),
 263                 sample1: i32::from(self.samples[ch + self.channels]),
 264                 coef1:   ADAPT_COEFFS[idx][0],
 265                 coef2:   ADAPT_COEFFS[idx][1],
 266                 delta:   16,
 267             };
 268         if self.channels == 1 {
 269             for samp in self.samples.iter().skip(2).take(len - 2) {
 270                 let pred = dec.calc_pred();
 271                 dec.update(pred);
 272                 let diff = i64::from(*samp) - i64::from(pred);
 273                 dist += diff * diff;
 274             }
 275         } else {
 276             for samp in self.samples.chunks(2).skip(2).take(len - 2) {
 277                 let pred = dec.calc_pred();
 278                 dec.update(pred);
 279                 let diff = i64::from(samp[ch]) - i64::from(pred);
 280                 dist += diff * diff;
 281             }
 282         }
 283         dist
 284     }
 285     fn calculate_mul(delta: i32, diff: i32) -> u8 {
 286         ((diff / delta).max(-8).min(7) & 0xF) as u8
 287     }
 288     fn calc_block_size(nsamps: usize, channels: usize) -> usize {
 289         (nsamps - 2) * channels / 2 + 7 * channels
 290     }
 291 }
 292
 293 impl NAEncoder for MSADPCMEncoder {
 294     fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
 295         match encinfo.format {
 296             NACodecTypeInfo::None => {
 297                 let mut ofmt = EncodeParameters::default();
 298                 ofmt.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 1, SND_S16_FORMAT, DEFAULT_BLOCK_LEN));
 299                 return Ok(ofmt);
 300             },
 301             NACodecTypeInfo::Video(_) => return Err(EncoderError::FormatError),
 302             NACodecTypeInfo::Audio(ainfo) => {
 303                 let mut outinfo = ainfo;
 304                 outinfo.channels = outinfo.channels.min(2);
 305                 if outinfo.format != SND_S16P_FORMAT && outinfo.format != SND_S16_FORMAT {
 306                     outinfo.format = SND_S16_FORMAT;
 307                 }
 308                 if outinfo.block_len == 0 {
 309                     outinfo.block_len = DEFAULT_BLOCK_LEN;
 310                 }
 311                 if outinfo.block_len < 2 {
 312                     outinfo.block_len = 2;
 313                 }
 314                 if (outinfo.channels == 1) && ((outinfo.block_len & 1) == 1) {
 315                     outinfo.block_len += 1;
 316                 }
 317                 let mut ofmt = EncodeParameters::default();
 318                 ofmt.format = NACodecTypeInfo::Audio(outinfo);
 319                 return Ok(ofmt);
 320             }
 321         };
 322     }
 323     fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
 324         match encinfo.format {
 325             NACodecTypeInfo::None => Err(EncoderError::FormatError),
 326             NACodecTypeInfo::Video(_) => Err(EncoderError::FormatError),
 327             NACodecTypeInfo::Audio(ainfo) => {
 328                 if ainfo.format != SND_S16P_FORMAT && ainfo.format != SND_S16_FORMAT {
 329                     return Err(EncoderError::FormatError);
 330                 }
 331                 if ainfo.channels != 1 && ainfo.channels != 2 {
 332                     return Err(EncoderError::FormatError);
 333                 }
 334                 if ainfo.block_len < 2 || ((ainfo.block_len * (ainfo.channels as usize)) & 1) != 0 {
 335                     return Err(EncoderError::FormatError);
 336                 }
 337                 self.channels = ainfo.channels as usize;
 338                 self.block_len = ainfo.block_len;
 339
 340                 let soniton = NASoniton::new(4, 0);
 341                 let out_ainfo = NAAudioInfo::new(ainfo.sample_rate, ainfo.channels, soniton, Self::calc_block_size(self.block_len, self.channels));
 342                 let info = NACodecInfo::new("ms-adpcm", NACodecTypeInfo::Audio(out_ainfo), None);
 343                 let stream = NAStream::new(StreamType::Audio, stream_id, info.clone(), self.block_len as u32, ainfo.sample_rate).into_ref();
 344
 345                 self.stream = Some(stream.clone());
 346                 self.samples = Vec::with_capacity(self.block_len * self.channels);
 347                 self.srate = ainfo.sample_rate;
 348                 self.flush = false;
 349
 350                 Ok(stream)
 351             },
 352         }
 353     }
 354     fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
 355         let buf = frm.get_buffer();
 356         if let Some(ref abuf) = buf.get_abuf_i16() {
 357             let src = abuf.get_data();
 358             let len = abuf.get_length();
 359             let ch  = abuf.get_chmap().num_channels();
 360             if abuf.get_step() > 1 || ch == 1 {
 361                 self.samples.extend(src.iter().take(len * ch));
 362             } else {
 363                 let (src0, src1) = src.split_at(abuf.get_stride());
 364                 self.samples.reserve(len * 2);
 365                 for (s0, s1) in src0.iter().take(len).zip(src1.iter()) {
 366                     self.samples.push(*s0);
 367                     self.samples.push(*s1);
 368                 }
 369             }
 370             Ok(())
 371         } else {
 372             Err(EncoderError::InvalidParameters)
 373         }
 374     }
 375     fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
 376         if let Ok(pkt) = self.encode_packet() {
 377             Ok(Some(pkt))
 378         } else {
 379             Ok(None)
 380         }
 381     }
 382     fn flush(&mut self) -> EncoderResult<()> {
 383         self.flush = true;
 384         Ok(())
 385     }
 386 }
 387
 388 impl NAOptionHandler for MSADPCMEncoder {
 389     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 390     fn set_options(&mut self, _options: &[NAOption]) { }
 391     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 392 }
 393
 394 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
 395     Box::new(MSADPCMEncoder::new())
 396 }
 397
 398 #[cfg(test)]
 399 mod test {
 400     use nihav_core::codecs::*;
 401     use nihav_core::demuxers::*;
 402     use nihav_core::muxers::*;
 403     use nihav_codec_support::test::dec_video::*;
 404     use nihav_codec_support::test::enc_video::*;
 405     use crate::*;
 406     use nihav_commonfmt::*;
 407     #[cfg(feature="decoder_ms_adpcm")]
 408     #[test]
 409     fn test_ms_adpcm_decoder() {
 410         let mut dmx_reg = RegisteredDemuxers::new();
 411         generic_register_all_demuxers(&mut dmx_reg);
 412         let mut dec_reg = RegisteredDecoders::new();
 413         ms_register_all_codecs(&mut dec_reg);
 414
 415         test_decoding("avi", "ms-adpcm", "assets/MS/dance.avi", None, &dmx_reg, &dec_reg,
 416                       ExpectedTestResult::MD5([0x9d6619e1, 0x60d83560, 0xfe5c1fb7, 0xad5d130d]));
 417     }
 418     #[cfg(feature="encoder_ms_adpcm")]
 419     #[test]
 420     fn test_ms_adpcm_encoder() {
 421         let mut dmx_reg = RegisteredDemuxers::new();
 422         generic_register_all_demuxers(&mut dmx_reg);
 423         let mut dec_reg = RegisteredDecoders::new();
 424         generic_register_all_codecs(&mut dec_reg);
 425         ms_register_all_codecs(&mut dec_reg);
 426         let mut mux_reg = RegisteredMuxers::new();
 427         generic_register_all_muxers(&mut mux_reg);
 428         let mut enc_reg = RegisteredEncoders::new();
 429         ms_register_all_encoders(&mut enc_reg);
 430
 431         let dec_config = DecoderTestParams {
 432                 demuxer:        "avi",
 433                 in_name:        "assets/Indeo/laser05.avi",
 434                 stream_type:    StreamType::Audio,
 435                 limit:          None,
 436                 dmx_reg, dec_reg,
 437             };
 438         let enc_config = EncoderTestParams {
 439                 muxer:          "wav",
 440                 enc_name:       "ms-adpcm",
 441                 out_name:       "msadpcm.wav",
 442                 mux_reg, enc_reg,
 443             };
 444         let dst_ainfo = NAAudioInfo {
 445                 sample_rate:    0,
 446                 channels:       0,
 447                 format:         SND_S16_FORMAT,
 448                 block_len:      128,
 449             };
 450         let enc_params = EncodeParameters {
 451                 format:  NACodecTypeInfo::Audio(dst_ainfo),
 452                 quality: 0,
 453                 bitrate: 0,
 454                 tb_num:  0,
 455                 tb_den:  0,
 456                 flags:   0,
 457             };
 458         test_encoding_to_file(&dec_config, &enc_config, enc_params);
 459     }
 460 }