]>
Commit | Line | Data |
---|---|---|
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 | impl NAOptionHandler for MSADPCMDecoder { | |
165 | fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } | |
166 | fn set_options(&mut self, _options: &[NAOption]) { } | |
167 | fn query_option_value(&self, _name: &str) -> Option<NAValue> { None } | |
168 | } | |
169 | ||
170 | pub fn get_decoder() -> Box<dyn NADecoder + Send> { | |
171 | Box::new(MSADPCMDecoder::new()) | |
172 | } | |
173 | ||
174 | #[derive(Default)] | |
175 | struct MSADPCMEncoder { | |
176 | stream: Option<NAStreamRef>, | |
177 | samples: Vec<i16>, | |
178 | block_len: usize, | |
179 | channels: usize, | |
180 | flush: bool, | |
181 | srate: u32, | |
182 | } | |
183 | ||
184 | const DEFAULT_BLOCK_LEN: usize = 256; | |
185 | ||
186 | impl MSADPCMEncoder { | |
187 | fn new() -> Self { Self::default() } | |
188 | fn encode_packet(&mut self) -> EncoderResult<NAPacket> { | |
189 | if self.samples.len() == 0 { | |
190 | return Err(EncoderError::TryAgain); | |
191 | } | |
192 | let len = (self.samples.len() / self.channels).min(self.block_len); | |
193 | if len < self.block_len && !self.flush { | |
194 | return Err(EncoderError::TryAgain); | |
195 | } | |
196 | if len < 2 { | |
197 | self.flush = false; | |
198 | return Err(EncoderError::TryAgain); | |
199 | } | |
200 | ||
201 | let mut dbuf = vec![0u8; Self::calc_block_size(len, self.channels)]; | |
202 | let mut mw = MemoryWriter::new_write(dbuf.as_mut_slice()); | |
203 | let mut bw = ByteWriter::new(&mut mw); | |
204 | ||
205 | let mut best_idx = [0usize; 2]; | |
206 | for ch in 0..self.channels { | |
207 | let mut best_dist = std::i64::MAX; | |
208 | for i in 0..ADAPT_COEFFS.len() { | |
209 | let dist = self.calc_dist(ch, i, len); | |
210 | if dist < best_dist { | |
211 | best_dist = dist; | |
212 | best_idx[ch] = i; | |
213 | } | |
214 | } | |
215 | bw.write_byte(best_idx[ch] as u8)?; | |
216 | } | |
217 | let mut dec = [Predictor::default(), Predictor::default()]; | |
218 | for ch in 0..self.channels { | |
219 | dec[ch].sample1 = i32::from(self.samples[ch + self.channels]); | |
220 | dec[ch].sample2 = i32::from(self.samples[ch]); | |
221 | dec[ch].coef1 = ADAPT_COEFFS[best_idx[ch]][0]; | |
222 | dec[ch].coef2 = ADAPT_COEFFS[best_idx[ch]][1]; | |
223 | if len > 2 { | |
224 | let pred = dec[ch].calc_pred(); | |
225 | dec[ch].delta = ((i32::from(self.samples[ch + self.channels * 2]) - pred).abs() / 4).max(16); | |
226 | } else { | |
227 | dec[ch].delta = 16; | |
228 | } | |
229 | } | |
230 | for ch in 0..self.channels { | |
231 | bw.write_u16le(dec[ch].delta as u16)?; | |
232 | } | |
233 | for ch in 0..self.channels { | |
234 | bw.write_u16le(dec[ch].sample1 as u16)?; | |
235 | } | |
236 | for ch in 0..self.channels { | |
237 | bw.write_u16le(dec[ch].sample2 as u16)?; | |
238 | } | |
239 | if self.channels == 1 { | |
240 | for samps in self.samples.chunks(2).skip(1).take(len/2 - 1) { | |
241 | let diff = i32::from(samps[0]) - dec[0].calc_pred(); | |
242 | let nib0 = Self::calculate_mul(dec[0].delta, diff); | |
243 | dec[0].expand_nibble(nib0); | |
244 | let diff = i32::from(samps[1]) - dec[0].calc_pred(); | |
245 | let nib1 = Self::calculate_mul(dec[0].delta, diff); | |
246 | dec[0].expand_nibble(nib1); | |
247 | bw.write_byte(nib0 * 16 + nib1)?; | |
248 | } | |
249 | } else { | |
250 | for samps in self.samples.chunks(2).skip(2).take(len - 2) { | |
251 | let diff = i32::from(samps[0]) - dec[0].calc_pred(); | |
252 | let nib0 = Self::calculate_mul(dec[0].delta, diff); | |
253 | dec[0].expand_nibble(nib0); | |
254 | let diff = i32::from(samps[1]) - dec[1].calc_pred(); | |
255 | let nib1 = Self::calculate_mul(dec[1].delta, diff); | |
256 | dec[1].expand_nibble(nib1); | |
257 | bw.write_byte(nib0 * 16 + nib1)?; | |
258 | } | |
259 | } | |
260 | self.samples.drain(..len * self.channels); | |
261 | drop(bw); | |
262 | let ts = NATimeInfo::new(None, None, Some(1), 1, self.srate); | |
263 | Ok(NAPacket::new(self.stream.clone().unwrap(), ts, true, dbuf)) | |
264 | } | |
265 | fn calc_dist(&self, ch: usize, idx: usize, len: usize) -> i64 { | |
266 | let mut dist = 0; | |
267 | let mut dec = Predictor { | |
268 | sample2: i32::from(self.samples[ch]), | |
269 | sample1: i32::from(self.samples[ch + self.channels]), | |
270 | coef1: ADAPT_COEFFS[idx][0], | |
271 | coef2: ADAPT_COEFFS[idx][1], | |
272 | delta: 16, | |
273 | }; | |
274 | if self.channels == 1 { | |
275 | for samp in self.samples.iter().skip(2).take(len - 2) { | |
276 | let pred = dec.calc_pred(); | |
277 | dec.update(pred); | |
278 | let diff = i64::from(*samp) - i64::from(pred); | |
279 | dist += diff * diff; | |
280 | } | |
281 | } else { | |
282 | for samp in self.samples.chunks(2).skip(2).take(len - 2) { | |
283 | let pred = dec.calc_pred(); | |
284 | dec.update(pred); | |
285 | let diff = i64::from(samp[ch]) - i64::from(pred); | |
286 | dist += diff * diff; | |
287 | } | |
288 | } | |
289 | dist | |
290 | } | |
291 | fn calculate_mul(delta: i32, diff: i32) -> u8 { | |
292 | ((diff / delta).max(-8).min(7) & 0xF) as u8 | |
293 | } | |
294 | fn calc_block_size(nsamps: usize, channels: usize) -> usize { | |
295 | (nsamps - 2) * channels / 2 + 7 * channels | |
296 | } | |
297 | } | |
298 | ||
299 | impl NAEncoder for MSADPCMEncoder { | |
300 | fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> { | |
301 | match encinfo.format { | |
302 | NACodecTypeInfo::None => { | |
303 | let mut ofmt = EncodeParameters::default(); | |
304 | ofmt.format = NACodecTypeInfo::Audio(NAAudioInfo::new(0, 1, SND_S16_FORMAT, DEFAULT_BLOCK_LEN)); | |
305 | return Ok(ofmt); | |
306 | }, | |
307 | NACodecTypeInfo::Video(_) => return Err(EncoderError::FormatError), | |
308 | NACodecTypeInfo::Audio(ainfo) => { | |
309 | let mut outinfo = ainfo; | |
310 | outinfo.channels = outinfo.channels.min(2); | |
311 | if outinfo.format != SND_S16P_FORMAT && outinfo.format != SND_S16_FORMAT { | |
312 | outinfo.format = SND_S16_FORMAT; | |
313 | } | |
314 | if outinfo.block_len == 0 { | |
315 | outinfo.block_len = DEFAULT_BLOCK_LEN; | |
316 | } | |
317 | if outinfo.block_len < 2 { | |
318 | outinfo.block_len = 2; | |
319 | } | |
320 | if (outinfo.channels == 1) && ((outinfo.block_len & 1) == 1) { | |
321 | outinfo.block_len += 1; | |
322 | } | |
323 | let mut ofmt = EncodeParameters::default(); | |
324 | ofmt.format = NACodecTypeInfo::Audio(outinfo); | |
325 | return Ok(ofmt); | |
326 | } | |
327 | }; | |
328 | } | |
329 | fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> { | |
330 | match encinfo.format { | |
331 | NACodecTypeInfo::None => Err(EncoderError::FormatError), | |
332 | NACodecTypeInfo::Video(_) => Err(EncoderError::FormatError), | |
333 | NACodecTypeInfo::Audio(ainfo) => { | |
334 | if ainfo.format != SND_S16P_FORMAT && ainfo.format != SND_S16_FORMAT { | |
335 | return Err(EncoderError::FormatError); | |
336 | } | |
337 | if ainfo.channels != 1 && ainfo.channels != 2 { | |
338 | return Err(EncoderError::FormatError); | |
339 | } | |
340 | if ainfo.block_len < 2 || ((ainfo.block_len * (ainfo.channels as usize)) & 1) != 0 { | |
341 | return Err(EncoderError::FormatError); | |
342 | } | |
343 | self.channels = ainfo.channels as usize; | |
344 | self.block_len = ainfo.block_len; | |
345 | ||
346 | let soniton = NASoniton::new(4, 0); | |
347 | let out_ainfo = NAAudioInfo::new(ainfo.sample_rate, ainfo.channels, soniton, Self::calc_block_size(self.block_len, self.channels)); | |
348 | let info = NACodecInfo::new("ms-adpcm", NACodecTypeInfo::Audio(out_ainfo), None); | |
349 | let stream = NAStream::new(StreamType::Audio, stream_id, info.clone(), self.block_len as u32, ainfo.sample_rate).into_ref(); | |
350 | ||
351 | self.stream = Some(stream.clone()); | |
352 | self.samples = Vec::with_capacity(self.block_len * self.channels); | |
353 | self.srate = ainfo.sample_rate; | |
354 | self.flush = false; | |
355 | ||
356 | Ok(stream) | |
357 | }, | |
358 | } | |
359 | } | |
360 | fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> { | |
361 | let buf = frm.get_buffer(); | |
362 | if let Some(ref abuf) = buf.get_abuf_i16() { | |
363 | let src = abuf.get_data(); | |
364 | let len = abuf.get_length(); | |
365 | let ch = abuf.get_chmap().num_channels(); | |
366 | if abuf.get_step() > 1 || ch == 1 { | |
367 | self.samples.extend(src.iter().take(len * ch)); | |
368 | } else { | |
369 | let (src0, src1) = src.split_at(abuf.get_stride()); | |
370 | self.samples.reserve(len * 2); | |
371 | for (s0, s1) in src0.iter().take(len).zip(src1.iter()) { | |
372 | self.samples.push(*s0); | |
373 | self.samples.push(*s1); | |
374 | } | |
375 | } | |
376 | Ok(()) | |
377 | } else { | |
378 | Err(EncoderError::InvalidParameters) | |
379 | } | |
380 | } | |
381 | fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> { | |
382 | if let Ok(pkt) = self.encode_packet() { | |
383 | Ok(Some(pkt)) | |
384 | } else { | |
385 | Ok(None) | |
386 | } | |
387 | } | |
388 | fn flush(&mut self) -> EncoderResult<()> { | |
389 | self.flush = true; | |
390 | Ok(()) | |
391 | } | |
392 | } | |
393 | ||
394 | impl NAOptionHandler for MSADPCMEncoder { | |
395 | fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } | |
396 | fn set_options(&mut self, _options: &[NAOption]) { } | |
397 | fn query_option_value(&self, _name: &str) -> Option<NAValue> { None } | |
398 | } | |
399 | ||
400 | pub fn get_encoder() -> Box<dyn NAEncoder + Send> { | |
401 | Box::new(MSADPCMEncoder::new()) | |
402 | } | |
403 | ||
404 | #[cfg(test)] | |
405 | mod test { | |
406 | use nihav_core::codecs::*; | |
407 | use nihav_core::demuxers::*; | |
408 | use nihav_core::muxers::*; | |
409 | use nihav_codec_support::test::dec_video::*; | |
410 | use nihav_codec_support::test::enc_video::*; | |
411 | use crate::*; | |
412 | use nihav_commonfmt::*; | |
413 | #[cfg(feature="decoder_ms_adpcm")] | |
414 | #[test] | |
415 | fn test_ms_adpcm_decoder() { | |
416 | let mut dmx_reg = RegisteredDemuxers::new(); | |
417 | generic_register_all_demuxers(&mut dmx_reg); | |
418 | let mut dec_reg = RegisteredDecoders::new(); | |
419 | ms_register_all_codecs(&mut dec_reg); | |
420 | ||
421 | test_decoding("avi", "ms-adpcm", "assets/MS/dance.avi", None, &dmx_reg, &dec_reg, | |
422 | ExpectedTestResult::MD5([0x9d6619e1, 0x60d83560, 0xfe5c1fb7, 0xad5d130d])); | |
423 | } | |
424 | #[cfg(feature="encoder_ms_adpcm")] | |
425 | #[test] | |
426 | fn test_ms_adpcm_encoder() { | |
427 | let mut dmx_reg = RegisteredDemuxers::new(); | |
428 | generic_register_all_demuxers(&mut dmx_reg); | |
429 | let mut dec_reg = RegisteredDecoders::new(); | |
430 | generic_register_all_codecs(&mut dec_reg); | |
431 | ms_register_all_codecs(&mut dec_reg); | |
432 | let mut mux_reg = RegisteredMuxers::new(); | |
433 | generic_register_all_muxers(&mut mux_reg); | |
434 | let mut enc_reg = RegisteredEncoders::new(); | |
435 | ms_register_all_encoders(&mut enc_reg); | |
436 | ||
437 | let dec_config = DecoderTestParams { | |
438 | demuxer: "avi", | |
439 | in_name: "assets/Indeo/laser05.avi", | |
440 | stream_type: StreamType::Audio, | |
441 | limit: None, | |
442 | dmx_reg, dec_reg, | |
443 | }; | |
444 | let enc_config = EncoderTestParams { | |
445 | muxer: "wav", | |
446 | enc_name: "ms-adpcm", | |
447 | out_name: "msadpcm.wav", | |
448 | mux_reg, enc_reg, | |
449 | }; | |
450 | let dst_ainfo = NAAudioInfo { | |
451 | sample_rate: 0, | |
452 | channels: 0, | |
453 | format: SND_S16_FORMAT, | |
454 | block_len: 128, | |
455 | }; | |
456 | let enc_params = EncodeParameters { | |
457 | format: NACodecTypeInfo::Audio(dst_ainfo), | |
458 | quality: 0, | |
459 | bitrate: 0, | |
460 | tb_num: 0, | |
461 | tb_den: 0, | |
462 | flags: 0, | |
463 | }; | |
464 | test_encoding_to_file(&dec_config, &enc_config, enc_params); | |
465 | } | |
466 | } |