nihav-duck/src/codecs/dkadpcm.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::byteio::*;
   3 use nihav_codec_support::codecs::imaadpcm::*;
   4 use std::str::FromStr;
   5
   6 struct DuckADPCMDecoder {
   7     ainfo:      NAAudioInfo,
   8     chmap:      NAChannelMap,
   9     is_dk3:     bool,
  10     ch_state:   [IMAState; 2],
  11     block_len:  usize,
  12 }
  13
  14 impl DuckADPCMDecoder {
  15     fn new(is_dk3: bool) -> Self {
  16         Self {
  17             ainfo:      NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
  18             chmap:      NAChannelMap::new(),
  19             is_dk3,
  20             ch_state:   [IMAState::new(), IMAState::new()],
  21             block_len:  0,
  22         }
  23     }
  24 }
  25
  26 impl NADecoder for DuckADPCMDecoder {
  27     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
  28         if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
  29             validate!(ainfo.get_block_len() > 16);
  30             self.block_len = ainfo.get_block_len();
  31             let channels = ainfo.get_channels();
  32             validate!(channels == 2 || (!self.is_dk3 && channels == 1));
  33             let len = if self.is_dk3 {
  34                     ((self.block_len - 16) * 2 / 3) * 2
  35                 } else {
  36                     (self.block_len - 4 * (channels as usize)) * 2 / (channels as usize)
  37                 };
  38             self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(), channels, SND_S16P_FORMAT, len);
  39             self.chmap = NAChannelMap::from_str(if channels == 1 { "C" } else { "L,R" }).unwrap();
  40             Ok(())
  41         } else {
  42             Err(DecoderError::InvalidData)
  43         }
  44     }
  45     #[allow(clippy::identity_op)]
  46     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
  47         let info = pkt.get_stream().get_info();
  48         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
  49             let pktbuf = pkt.get_buffer();
  50             validate!(pktbuf.len() > (if self.is_dk3 { 16 } else { 4 * self.chmap.num_channels() }));
  51             let nblocks = pktbuf.len() / self.block_len;
  52             let out_block_len = self.ainfo.get_block_len();
  53             let duration = out_block_len * nblocks;
  54             let abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
  55             let mut adata = abuf.get_abuf_i16().unwrap();
  56             let mut off0 = adata.get_offset(0);
  57             let mut off1 = adata.get_offset(1);
  58             let dst = adata.get_data_mut().unwrap();
  59
  60             for blk in pktbuf.chunks_exact(self.block_len) {
  61                 let mut mr = MemoryReader::new_read(blk);
  62                 let mut br = ByteReader::new(&mut mr);
  63                 if self.is_dk3 {
  64                     let _typeid                 = br.read_byte()?;
  65                     let _version                = br.read_byte()?;
  66                     let _srate                  = br.read_u32le()?;
  67                     let samples                 = br.read_u32le()? as usize;
  68                     let sumpred                 = br.read_u16le()? as i16;
  69                     let diffpred                = br.read_u16le()? as i16;
  70                     let sumstep                 = br.read_byte()?;
  71                     let diffstep                = br.read_byte()?;
  72                     validate!(sumstep <= IMA_MAX_STEP && diffstep <= IMA_MAX_STEP);
  73                     validate!(samples <= out_block_len);
  74                     self.ch_state[0].reset(sumpred,  sumstep);
  75                     self.ch_state[1].reset(diffpred, diffstep);
  76                     let mut last_nib = 0;
  77                     let mut diff_val: i32 = i32::from(diffpred);
  78                     for x in (0..out_block_len).step_by(2) {
  79                         let nib0;
  80                         let nib1;
  81                         let nib2;
  82                         if (x & 2) == 0 {
  83                             let b0              = br.read_byte()?;
  84                             let b1              = br.read_byte()?;
  85                             nib0 = b0 & 0xF;
  86                             nib1 = b0 >> 4;
  87                             nib2 = b1 & 0xF;
  88                             last_nib = b1 >> 4;
  89                         } else {
  90                             let b0              = br.read_byte()?;
  91                             nib0 = last_nib;
  92                             nib1 = b0 & 0xF;
  93                             nib2 = b0 >> 4;
  94                         }
  95                         let sum0 = i32::from(self.ch_state[0].expand_sample(nib0));
  96                         let diff = i32::from(self.ch_state[1].expand_sample(nib1));
  97                         let sum1 = i32::from(self.ch_state[0].expand_sample(nib2));
  98                         diff_val = (diff_val + diff) >> 1;
  99                         dst[off0 + x + 0] = (sum0 + diff_val) as i16;
 100                         dst[off1 + x + 0] = (sum0 - diff_val) as i16;
 101                         diff_val = (diff_val + diff) >> 1;
 102                         dst[off0 + x + 1] = (sum1 + diff_val) as i16;
 103                         dst[off1 + x + 1] = (sum1 - diff_val) as i16;
 104                         diff_val = diff;
 105                     }
 106                 } else {
 107                     let nchannels = self.chmap.num_channels();
 108                     for ch in 0..nchannels {
 109                         let pred                = br.read_u16le()? as i16;
 110                         let step                = br.read_byte()?;
 111                                                   br.read_skip(1)?;
 112                         validate!(step <= IMA_MAX_STEP);
 113                         self.ch_state[ch].reset(pred, step);
 114                     }
 115                     if nchannels == 2 {
 116                         for x in 0..out_block_len {
 117                             let b               = br.read_byte()?;
 118                             dst[off0 + x] = self.ch_state[0].expand_sample(b >> 4);
 119                             dst[off1 + x] = self.ch_state[1].expand_sample(b & 0xF);
 120                         }
 121                     } else {
 122                         for x in (0..out_block_len).step_by(2) {
 123                             let b               = br.read_byte()?;
 124                             dst[off0 + x + 0] = self.ch_state[0].expand_sample(b >> 4);
 125                             dst[off0 + x + 1] = self.ch_state[0].expand_sample(b & 0xF);
 126                         }
 127                     }
 128                 }
 129                 off0 += out_block_len;
 130                 off1 += out_block_len;
 131             }
 132             let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
 133             frm.set_duration(Some(duration as u64));
 134             frm.set_keyframe(false);
 135             Ok(frm.into_ref())
 136         } else {
 137             Err(DecoderError::InvalidData)
 138         }
 139     }
 140     fn flush(&mut self) {
 141     }
 142 }
 143
 144 impl NAOptionHandler for DuckADPCMDecoder {
 145     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 146     fn set_options(&mut self, _options: &[NAOption]) { }
 147     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 148 }
 149
 150 pub fn get_decoder_dk3() -> Box<dyn NADecoder + Send> {
 151     Box::new(DuckADPCMDecoder::new(true))
 152 }
 153
 154 pub fn get_decoder_dk4() -> Box<dyn NADecoder + Send> {
 155     Box::new(DuckADPCMDecoder::new(false))
 156 }
 157
 158 #[cfg(test)]
 159 mod test {
 160     use nihav_core::codecs::RegisteredDecoders;
 161     use nihav_core::demuxers::RegisteredDemuxers;
 162     use nihav_codec_support::test::dec_video::*;
 163     use crate::duck_register_all_decoders;
 164     use nihav_commonfmt::generic_register_all_demuxers;
 165     #[test]
 166     fn test_dk3() {
 167         let mut dmx_reg = RegisteredDemuxers::new();
 168         generic_register_all_demuxers(&mut dmx_reg);
 169         let mut dec_reg = RegisteredDecoders::new();
 170         duck_register_all_decoders(&mut dec_reg);
 171
 172         //let file = "assets/Duck/AVI-DUCK-dk3.duk";
 173         //test_decode_audio("avi", file, Some(100), None/*Some("dk3")*/, &dmx_reg, &dec_reg);
 174         // sample: https://samples.mplayerhq.hu/V-codecs/DUCK/AVI-DUCK-dk3.duk
 175         test_decoding("avi", "adpcm-dk3", "assets/Duck/AVI-DUCK-dk3.duk", None, &dmx_reg, &dec_reg,
 176                       ExpectedTestResult::MD5([0xa48fae0a, 0xa536b27f, 0x169ecc19, 0x8436fade]));
 177     }
 178     #[test]
 179     fn test_dk4() {
 180         let mut dmx_reg = RegisteredDemuxers::new();
 181         generic_register_all_demuxers(&mut dmx_reg);
 182         let mut dec_reg = RegisteredDecoders::new();
 183         duck_register_all_decoders(&mut dec_reg);
 184
 185 //        let file = "assets/Duck/virtuafighter2-opening1.avi";
 186 //        test_decode_audio("avi", file, Some(100), None/*Some("dk4")*/, &dmx_reg, &dec_reg);
 187         // sample: https://samples.mplayerhq.hu/V-codecs/DUCK/virtuafighter2-opening1.avi
 188         test_decoding("avi", "adpcm-dk4", "assets/Duck/virtuafighter2-opening1.avi", None, &dmx_reg, &dec_reg,
 189                       ExpectedTestResult::MD5([0x04e40d15, 0xf65b3427, 0x1dd5181f, 0xf321b56f]));
 190     }
 191 }