]> git.nihav.org Git - nihav.git/blob - nihav-llaudio/src/codecs/flac.rs
fix clippy warnings
[nihav.git] / nihav-llaudio / src / codecs / flac.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
6 const MAX_SAMPLES: usize = 32768;
7
8 #[derive(Clone,Copy,PartialEq)]
9 enum StereoMode {
10 Normal,
11 LeftSide,
12 SideRight,
13 MidSide,
14 }
15
16 struct FlacDecoder {
17 ainfo: NAAudioInfo,
18 chmap: NAChannelMap,
19 min_blk_size: usize,
20 max_blk_size: usize,
21 min_frm_size: usize,
22 max_frm_size: usize,
23 channels: u8,
24 bits: u8,
25 srate: u32,
26 residues: [Vec<i32>; 8],
27 }
28
29 fn decode_partition(br: &mut BitReader, dst: &mut [i32], k: u8) -> DecoderResult<()> {
30 for el in dst.iter_mut() {
31 let val = br.read_code(UintCodeType::Rice(k))?;
32 if (val & 1) == 0 {
33 *el = (val >> 1) as i32;
34 } else {
35 *el = -(((val + 1) >> 1) as i32);
36 }
37 }
38 Ok(())
39 }
40
41 fn decode_residual(br: &mut BitReader, dst: &mut [i32], order: usize) -> DecoderResult<()> {
42 let mode = br.read(2)?;
43 validate!(mode < 2);
44 let rice_k = if mode == 0 { 4 } else { 5 };
45 let esc = (1 << rice_k) - 1;
46
47 let num_partitions = 1 << br.read(4)?;
48 let tot_size = dst.len() + order;
49 validate!((tot_size % num_partitions) == 0);
50 let psize = tot_size / num_partitions;
51 validate!(psize >= order);
52 let mut off = psize - order;
53 let k = br.read(rice_k)? as u8;
54 if k != esc {
55 decode_partition(br, &mut dst[..off], k)?;
56 } else {
57 let bits = br.read(5)? as u8;
58 for el in dst.iter_mut().take(off) {
59 *el = br.read_s(bits)?;
60 }
61 }
62 for _ in 1..num_partitions {
63 let k = br.read(rice_k)? as u8;
64 if k != esc {
65 decode_partition(br, &mut dst[off..][..psize], k)?;
66 } else {
67 let bits = br.read(5)? as u8;
68 for el in dst[off..].iter_mut().take(psize) {
69 *el = br.read_s(bits)?;
70 }
71 }
72 off += psize;
73 }
74
75 Ok(())
76 }
77
78 fn apply_fixed_predictor(dst: &mut [i32], order: usize) {
79 match order {
80 1 => {
81 let mut last = dst[0];
82 for el in dst.iter_mut().skip(1) {
83 *el += last;
84 last = *el;
85 }
86 },
87 2 => {
88 let mut last0 = dst[1];
89 let mut last1 = last0 - dst[0];
90 for el in dst.iter_mut().skip(2) {
91 last1 += *el;
92 last0 += last1;
93 *el = last0;
94 }
95 },
96 3 => {
97 let mut last0 = dst[2];
98 let mut last1 = last0 - dst[1];
99 let mut last2 = last1 - dst[1] + dst[0];
100 for el in dst.iter_mut().skip(3) {
101 last2 += *el;
102 last1 += last2;
103 last0 += last1;
104 *el = last0;
105 }
106 },
107 4 => {
108 let mut last0 = dst[3];
109 let mut last1 = last0 - dst[2];
110 let mut last2 = last1 - dst[2] + dst[1];
111 let mut last3 = last2 - dst[2] + 2 * dst[1] - dst[0];
112 for el in dst.iter_mut().skip(4) {
113 last3 += *el;
114 last2 += last3;
115 last1 += last2;
116 last0 += last1;
117 *el = last0;
118 }
119 },
120 _ => unreachable!(),
121 };
122 }
123
124 fn apply_lpc(dst: &mut [i32], filt: &[i32; 32], order: usize, shift: u8) {
125 for i in order..dst.len() {
126 let mut sum = 0i64;
127 for (coef, filt) in dst[i - order..].iter().take(order).zip(filt.iter()) {
128 sum += i64::from(*coef) * i64::from(*filt);
129 }
130 dst[i] += (sum >> shift) as i32;
131 }
132 }
133
134 impl FlacDecoder {
135 fn new() -> Self {
136 Self {
137 ainfo: NAAudioInfo::new(0, 1, SND_S16P_FORMAT, 0),
138 chmap: NAChannelMap::new(),
139 min_blk_size: 0,
140 max_blk_size: 0,
141 min_frm_size: 0,
142 max_frm_size: 0,
143 channels: 0,
144 bits: 0,
145 srate: 0,
146 residues: [vec![0; MAX_SAMPLES], vec![0; MAX_SAMPLES],
147 vec![0; MAX_SAMPLES], vec![0; MAX_SAMPLES],
148 vec![0; MAX_SAMPLES], vec![0; MAX_SAMPLES],
149 vec![0; MAX_SAMPLES], vec![0; MAX_SAMPLES]],
150 }
151 }
152 fn apply_chmod(&mut self, blocksize: usize, chmod: StereoMode) {
153 match chmod {
154 StereoMode::Normal => {},
155 StereoMode::LeftSide => {
156 for i in 0..blocksize {
157 self.residues[1][i] = self.residues[0][i].wrapping_sub(self.residues[1][i]);
158 }
159 },
160 StereoMode::SideRight => {
161 for i in 0..blocksize {
162 self.residues[0][i] = self.residues[0][i].wrapping_add(self.residues[1][i]);
163 }
164 },
165 StereoMode::MidSide => {
166 for i in 0..blocksize {
167 let r = self.residues[0][i].wrapping_sub(self.residues[1][i] >> 1);
168 self.residues[0][i] = self.residues[1][i].wrapping_add(r);
169 self.residues[1][i] = r;
170 }
171 },
172 };
173 }
174 fn decode_subframe(&mut self, br: &mut BitReader, channel: usize, blocksize: usize, mut samp_bits: u8) -> DecoderResult<()> {
175 let marker = br.read(1)?;
176 validate!(marker == 0);
177 let sftype = br.read(6)?;
178
179 if br.read_bool()? {
180 let nbits = br.read_code(UintCodeType::UnaryZeroes)?;
181 validate!(nbits < 32 && samp_bits > nbits as u8);
182 samp_bits -= nbits as u8;
183 }
184
185 let dst = &mut self.residues[channel][..blocksize];
186 match sftype {
187 0x00 => {
188 let val = br.read_s(samp_bits)?;
189 for el in dst.iter_mut() {
190 *el = val;
191 }
192 },
193 0x01 => {
194 for el in dst.iter_mut() {
195 *el = br.read_s(samp_bits)?;
196 }
197 },
198 0x08..=0x0C => {
199 let order = (sftype - 0x08) as usize;
200 for el in dst.iter_mut().take(order) {
201 *el = br.read_s(samp_bits)?;
202 }
203 decode_residual(br, &mut dst[order..], order)?;
204 if order > 0 {
205 apply_fixed_predictor(dst, order);
206 }
207 },
208 0x20..=0x3F => {
209 let order = (sftype - 0x20) as usize + 1;
210 for el in dst.iter_mut().take(order) {
211 *el = br.read_s(samp_bits)?;
212 }
213 let precision = br.read(4)? as u8 + 1;
214 validate!(precision < 16);
215 let shift = br.read(5)? as u8;
216 let mut filter = [0i32; 32];
217 for el in filter[..order].iter_mut().rev() {
218 *el = br.read_s(precision)?;
219 }
220 decode_residual(br, &mut dst[order..], order)?;
221 apply_lpc(dst, &filter, order, shift);
222 },
223 _ => return Err(DecoderError::InvalidData),
224 };
225
226 Ok(())
227 }
228 }
229
230 impl NADecoder for FlacDecoder {
231 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
232 const DEFAULT_CHANNEL_MAPS: [&str; 8] = [
233 "C",
234 "L,R",
235 "L,R,C",
236 "L,R,Ls,Rs",
237 "L,R,C,Ls,Rs",
238 "L,R,C,LFE,Ls,Rs",
239 "L,R,C,LFE,Cs,Ls,Rs",
240 "L,R,C,LFE,Ls,Rs,Lss,Rss"
241 ];
242 if let NACodecTypeInfo::Audio(_ainfo) = info.get_properties() {
243 if let Some(buf) = info.get_extradata() {
244 validate!(buf.len() >= 22);
245
246 let mut mr = MemoryReader::new_read(&buf);
247 let mut br = ByteReader::new(&mut mr);
248
249 self.min_blk_size = br.read_u16be()? as usize;
250 self.max_blk_size = br.read_u16be()? as usize;
251 self.min_frm_size = br.read_u24be()? as usize;
252 self.max_frm_size = br.read_u24be()? as usize;
253 let tmp = br.read_u64be()?;
254 self.srate = (tmp >> 44) as u32;
255 self.channels = (((tmp >> 41) & 7) + 1) as u8;
256 self.bits = (((tmp >> 36) & 0x1F) + 1) as u8;
257 //let tot_samples = tmp & ((1 << 36) - 1);
258
259 self.chmap = NAChannelMap::from_str(DEFAULT_CHANNEL_MAPS[(self.channels - 1) as usize]).unwrap();
260 let fmt = match self.bits {
261 8 | 12 | 16 => SND_S16P_FORMAT,
262 24 => SND_S32P_FORMAT,
263 _ => return Err(DecoderError::NotImplemented),
264 };
265
266 self.ainfo = NAAudioInfo::new(self.srate, self.channels as u8, fmt, self.max_blk_size.max(1));
267 Ok(())
268 } else {
269 Err(DecoderError::InvalidData)
270 }
271 } else {
272 Err(DecoderError::InvalidData)
273 }
274 }
275 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
276 let info = pkt.get_stream().get_info();
277 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
278 let pktbuf = pkt.get_buffer();
279 validate!(pktbuf.len() >= 9.max(self.min_frm_size));
280
281 let ref_crc = read_u16be(&pktbuf[pktbuf.len() - 2..]).unwrap_or(0);
282 let mut crc = 0;
283 for el in pktbuf.iter().take(pktbuf.len() - 2) {
284 crc = update_crc16(crc, *el);
285 }
286 if crc != ref_crc {
287 return Err(DecoderError::ChecksumError);
288 }
289
290 let mut br = BitReader::new(&pktbuf, BitReaderMode::BE);
291
292 let sync = br.read(14)?;
293 validate!(sync == 0x3FFE);
294 br.skip(1)?;
295 let _blocking = br.read(1)?;
296 let bsize_idx = br.read(4)?;
297 let srate_idx = br.read(4)?;
298 let chan_idx = br.read(4)?;
299 let bits_idx = br.read(3)?;
300 br.skip(1)?;
301 // UTF-8 encoded block or sample number
302 let byte = br.read(8)? as u8;
303 let len = (!byte).leading_zeros();
304 validate!(len <= 5 && len != 1);
305 if len > 1 {
306 for _ in 1..len {
307 let byte = br.read(8)?;
308 validate!((byte & 0xC0) == 0x80);
309 }
310 }
311 let blocksize = match bsize_idx {
312 0 => return Err(DecoderError::InvalidData),
313 1 => 192,
314 2..=5 => 576 << (bsize_idx - 2),
315 6 => br.read(8)? as usize + 1,
316 7 => br.read(16)? as usize + 1,
317 _ => 256 << (bsize_idx - 8),
318 };
319 let srate = match srate_idx {
320 0 => self.srate,
321 1 => 88200,
322 2 => 176400,
323 3 => 192000,
324 4 => 8000,
325 5 => 16000,
326 6 => 22050,
327 7 => 24000,
328 8 => 32000,
329 9 => 44100,
330 10 => 48000,
331 11 => 96000,
332 12 => br.read(8)? * 1000,
333 13 => br.read(16)?,
334 14 => br.read(16)? * 10,
335 _ => return Err(DecoderError::InvalidData),
336 };
337 validate!(srate != 0 && srate == self.srate);
338 let (channels, chmod) = match chan_idx {
339 0..=7 => (chan_idx as u8 + 1, StereoMode::Normal),
340 8 => (2, StereoMode::LeftSide),
341 9 => (2, StereoMode::SideRight),
342 10 => (2, StereoMode::MidSide),
343 _ => return Err(DecoderError::InvalidData),
344 };
345 validate!(channels == self.channels);
346 let bits = match bits_idx {
347 0 => self.bits,
348 1 => 8,
349 2 => 12,
350 4 => 16,
351 5 => 20,
352 6 => 24,
353 _ => return Err(DecoderError::InvalidData),
354 };
355 validate!(bits == self.bits);
356
357 let end = br.tell() / 8;
358 let ref_crc = br.read(8)? as u8;
359 let mut crc = 0;
360 for el in pktbuf.iter().take(end) {
361 crc = update_crc8(crc, *el);
362 }
363 if crc != ref_crc {
364 return Err(DecoderError::ChecksumError);
365 }
366
367 for ch in 0..(channels as usize) {
368 let samp_bits = match (chmod, ch) {
369 (StereoMode::LeftSide, 1) |
370 (StereoMode::SideRight, 0) |
371 (StereoMode::MidSide, 1) => self.bits + 1,
372 _ => self.bits,
373 };
374 validate!(samp_bits <= 32);
375 self.decode_subframe(&mut br, ch, blocksize, samp_bits)?;
376 }
377 if channels == 2 {
378 self.apply_chmod(blocksize, chmod);
379 }
380
381 let mut abuf = alloc_audio_buffer(self.ainfo, blocksize, self.chmap.clone())?;
382 let postshift = if self.bits == 24 { 8 } else { 16 - self.bits };
383 match abuf {
384 NABufferType::AudioI16(ref mut adata) => {
385 let stride = adata.get_stride();
386 let dst = adata.get_data_mut().unwrap();
387 let mut off = 0;
388 for residues in self.residues.iter().take(channels as usize) {
389 let dst = &mut dst[off..][..blocksize];
390 for (dst, src) in dst.iter_mut().zip(residues.iter()) {
391 *dst = (*src << postshift) as i16;
392 }
393 off += stride;
394 }
395 },
396 NABufferType::AudioI32(ref mut adata) => {
397 let stride = adata.get_stride();
398 let dst = adata.get_data_mut().unwrap();
399 let mut off = 0;
400 for residues in self.residues.iter().take(channels as usize) {
401 let dst = &mut dst[off..][..blocksize];
402 for (dst, src) in dst.iter_mut().zip(residues.iter()) {
403 *dst = *src << postshift;
404 }
405 off += stride;
406 }
407 },
408 _ => unreachable!(),
409 };
410
411 let mut frm = NAFrame::new_from_pkt(pkt, info, abuf);
412 frm.set_duration(Some(blocksize as u64));
413 Ok(frm.into_ref())
414 } else {
415 Err(DecoderError::InvalidData)
416 }
417 }
418 fn flush(&mut self) {
419 }
420 }
421
422 impl NAOptionHandler for FlacDecoder {
423 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
424 fn set_options(&mut self, _options: &[NAOption]) { }
425 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
426 }
427
428 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
429 Box::new(FlacDecoder::new())
430 }
431
432 #[derive(Clone,Copy,Default)]
433 struct FrameHeader {
434 blocksize: u32,
435 srate: u32,
436 channels: u8,
437 bits: u8,
438 time: u64,
439 blk_strat: bool,
440 }
441
442 #[derive(Default)]
443 struct FLACPacketiser {
444 hdr: FrameHeader,
445 buf: Vec<u8>,
446 ref_crc: u16,
447 cur_crc: u16,
448 end: usize,
449 hdr_ok: bool,
450 }
451
452 fn read_utf8(br: &mut BitReader) -> DecoderResult<u64> {
453 let byte = br.read(8)? as u8;
454 let len = (!byte).leading_zeros();
455 if (len == 1) || (len > 5) {
456 return Err(DecoderError::InvalidData);
457 }
458 if len > 1 {
459 let mut val = u64::from(byte << len >> len);
460 for _ in 1..len {
461 let byte = br.read(8)?;
462 if (byte & 0xC0) != 0x80 {
463 return Err(DecoderError::InvalidData);
464 }
465 val = (val << 6) | u64::from(byte & 0x3F);
466 }
467 Ok(val)
468 } else {
469 Ok(u64::from(byte))
470 }
471 }
472
473 impl FLACPacketiser {
474 fn new() -> Self { Self::default() }
475 fn parse_header(&self) -> DecoderResult<FrameHeader> {
476 if self.buf.len() < 5 {
477 return Err(DecoderError::ShortData);
478 }
479 let mut br = BitReader::new(&self.buf, BitReaderMode::BE);
480 let sync_code = br.read(14)?;
481 if sync_code != 0x3FFE {
482 return Err(DecoderError::InvalidData);
483 }
484 let marker = br.read(1)?;
485 if marker != 0 {
486 return Err(DecoderError::InvalidData);
487 }
488 let blk_strat = br.read_bool()?;
489 let bsize = br.read(4)?;
490 let srate_idx = br.read(4)? as u8;
491 let chan_idx = br.read(4)? as u8;
492 let bits = match br.read(3)? {
493 0 => 0,
494 1 => 8,
495 2 => 12,
496 4 => 16,
497 5 => 20,
498 6 => 24,
499 _ => return Err(DecoderError::InvalidData),
500 };
501 let marker = br.read(1)?;
502 if marker != 0 {
503 return Err(DecoderError::InvalidData);
504 }
505
506 let time = read_utf8(&mut br)?;
507
508 let blocksize = match bsize {
509 1 => 192,
510 2..=5 => 576 << (bsize - 2),
511 6 => br.read(8)? + 1,
512 7 => br.read(16)? + 1,
513 8..=15 => 256 << (bsize - 8),
514 _ => return Err(DecoderError::InvalidData),
515 };
516 let srate = match srate_idx {
517 0 => 0,
518 1 => 88200,
519 2 => 176400,
520 3 => 192000,
521 4 => 8000,
522 5 => 16000,
523 6 => 22050,
524 7 => 24000,
525 8 => 32000,
526 9 => 44100,
527 10 => 48000,
528 11 => 96000,
529 12 => br.read(8)? * 1000,
530 13 => br.read(16)?,
531 14 => br.read(16)? * 10,
532 _ => return Err(DecoderError::InvalidData),
533 };
534 let channels = match chan_idx {
535 0..=7 => chan_idx + 1,
536 8 | 9 | 10 => 2,
537 _ => return Err(DecoderError::InvalidData),
538 };
539
540 let hdr_size = br.tell() / 8;
541 let ref_crc = br.read(8)? as u8;
542 let mut crc = 0;
543 for &b in self.buf[..hdr_size].iter() {
544 crc = update_crc8(crc, b);
545 }
546 if crc != ref_crc {
547 return Err(DecoderError::ChecksumError);
548 }
549
550 Ok(FrameHeader{ blk_strat, time, srate, channels, bits, blocksize })
551 }
552 }
553
554 impl NAPacketiser for FLACPacketiser {
555 fn add_data(&mut self, src: &[u8]) -> bool {
556 self.buf.extend_from_slice(src);
557 self.buf.len() < 4096
558 }
559 fn parse_stream(&mut self, id: u32) -> DecoderResult<NAStreamRef> {
560 let hdr = self.parse_header()?;
561 let ainfo = NAAudioInfo::new(hdr.srate, hdr.channels, if hdr.bits <= 16 { SND_S16P_FORMAT } else { SND_S32P_FORMAT }, hdr.blocksize as usize);
562 let info = NACodecInfo::new("flac", NACodecTypeInfo::Audio(ainfo), None);
563 Ok(NAStream::new(StreamType::Audio, id, info, 1, hdr.srate, 0).into_ref())
564 }
565 fn skip_junk(&mut self) -> DecoderResult<usize> {
566 Err(DecoderError::NotImplemented)
567 }
568 fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult<Option<NAPacket>> {
569 if self.end == self.buf.len() || self.buf.len() < 5 {
570 return Err(DecoderError::ShortData);
571 }
572 if !self.hdr_ok {
573 self.hdr = self.parse_header()?;
574 self.hdr_ok = true;
575 self.cur_crc = 0;
576 for i in 0..5 {
577 self.cur_crc = update_crc16(self.cur_crc, self.buf[i]);
578 }
579 self.end = 5;
580 }
581 while self.end < self.buf.len() {
582 let b = self.buf[self.end];
583 self.end += 1;
584 match self.end {
585 0..=5 => unreachable!(),
586 6 => self.ref_crc = u16::from(b),
587 7 => self.ref_crc = (self.ref_crc << 8) | u16::from(b),
588 _ => {
589 let bbb = (self.ref_crc >> 8) as u8;
590 self.ref_crc = (self.ref_crc << 8) | u16::from(b);
591 self.cur_crc = update_crc16(self.cur_crc, bbb);
592 let mut found = self.ref_crc == self.cur_crc;
593 if self.end + 2 < self.buf.len() {
594 let b1 = self.buf[self.end];
595 let b2 = self.buf[self.end + 1];
596 if b1 != 0xFF || (b2 & 0xFC) != 0xF8 {
597 found = false;
598 }
599 }
600 if found {
601 let mut data = Vec::with_capacity(self.end);
602 data.extend_from_slice(&self.buf[..self.end]);
603 self.buf.drain(..self.end);
604 let mut ts = NATimeInfo::new(None, None, Some(u64::from(self.hdr.blocksize)), 1, self.hdr.srate);
605 ts.pts = if self.hdr.blk_strat {
606 Some(self.hdr.time)
607 } else {
608 Some(self.hdr.time * u64::from(self.hdr.blocksize))
609 };
610 self.end = 0;
611 self.hdr_ok = false;
612
613 return Ok(Some(NAPacket::new(stream, ts, true, data)));
614 }
615 },
616 }
617 }
618 Ok(None)
619 }
620 fn reset(&mut self) {
621 self.buf.clear();
622 self.end = 0;
623 self.hdr_ok = false;
624 }
625 }
626
627 pub fn get_packetiser() -> Box<dyn NAPacketiser + Send> {
628 Box::new(FLACPacketiser::new())
629 }
630
631 #[cfg(test)]
632 mod test {
633 use nihav_core::codecs::*;
634 use nihav_core::demuxers::*;
635 use nihav_codec_support::test::dec_video::*;
636 use crate::llaudio_register_all_decoders;
637 use crate::llaudio_register_all_demuxers;
638 #[test]
639 fn test_flac() {
640 let mut dmx_reg = RegisteredDemuxers::new();
641 llaudio_register_all_demuxers(&mut dmx_reg);
642 let mut dec_reg = RegisteredDecoders::new();
643 llaudio_register_all_decoders(&mut dec_reg);
644
645 test_decoding("flac", "flac", "assets/LLaudio/luckynight.flac", Some(6), &dmx_reg, &dec_reg,
646 ExpectedTestResult::MD5([0xe689787a, 0x032a98f7, 0xeb6e64f4, 0xfa652132]));
647 }
648 use std::io::{Read, Seek, SeekFrom};
649 #[test]
650 fn test_flac_packetiser() {
651 let mut dmx_reg = RegisteredDemuxers::new();
652 llaudio_register_all_demuxers(&mut dmx_reg);
653 let dmx_f = dmx_reg.find_demuxer("flac").unwrap();
654 let mut file = std::fs::File::open("assets/LLaudio/luckynight.flac").unwrap();
655 let mut fr = FileReader::new_read(&mut file);
656 let mut br = ByteReader::new(&mut fr);
657 let mut dmx = create_demuxer(dmx_f, &mut br).unwrap();
658
659 let mut pkt_sizes = Vec::new();
660 while let Ok(pkt) = dmx.get_frame() {
661 pkt_sizes.push(pkt.get_buffer().len());
662 }
663
664 let mut file = std::fs::File::open("assets/LLaudio/luckynight.flac").unwrap();
665 file.seek(SeekFrom::Start(0x115E)).unwrap();
666
667 let mut pkts = super::FLACPacketiser::new();
668 let mut buf = [0; 8192];
669 for _ in 0..16 {
670 file.read_exact(&mut buf).unwrap();
671 pkts.add_data(&buf);
672 }
673 let stream = pkts.parse_stream(0).unwrap();
674 let mut pkt_sizes2 = Vec::new();
675 let mut piter = pkt_sizes.iter();
676 loop {
677 let res = pkts.get_packet(stream.clone());
678 match res {
679 Ok(Some(pkt)) => {
680 assert_eq!(*piter.next().unwrap(), pkt.get_buffer().len());
681 pkt_sizes2.push(pkt.get_buffer().len());
682 continue;
683 },
684 Ok(None) | Err(DecoderError::ShortData) => {},
685 Err(err) => {
686 println!("error {:?}", err);
687 panic!("packetising error");
688 },
689 };
690 let ret = file.read(&mut buf);
691 match ret {
692 Ok(0) => {
693 let res = pkts.get_packet(stream.clone());
694 match res {
695 Ok(Some(pkt)) => {
696 assert_eq!(*piter.next().unwrap(), pkt.get_buffer().len());
697 pkt_sizes2.push(pkt.get_buffer().len());
698 continue;
699 },
700 Ok(None) | Err(DecoderError::ShortData) => break,
701 Err(err) => {
702 println!("error {:?}", err);
703 panic!("packetising error");
704 },
705 };
706 },
707 Ok(size) => pkts.add_data(&buf[..size]),
708 Err(err) => {
709 if err.kind() == std::io::ErrorKind::UnexpectedEof {
710 let res = pkts.get_packet(stream.clone());
711 match res {
712 Ok(Some(pkt)) => {
713 assert_eq!(*piter.next().unwrap(), pkt.get_buffer().len());
714 pkt_sizes2.push(pkt.get_buffer().len());
715 continue;
716 },
717 Ok(None) | Err(DecoderError::ShortData) => break,
718 Err(err) => {
719 println!("error {:?}", err);
720 panic!("packetising error");
721 },
722 };
723 } else {
724 println!(" {:?}", err.kind());
725 panic!("i/o error!");
726 }
727 },
728 };
729 }
730 assert_eq!(pkt_sizes.len(), pkt_sizes2.len());
731 }
732 }
733
734 fn update_crc8(crc: u8, byte: u8) -> u8 {
735 CRC8_TABLE[(crc ^ byte) as usize]
736 }
737
738 fn update_crc16(crc: u16, byte: u8) -> u16 {
739 (crc << 8) ^ CRC16_TABLE[(((crc >> 8) as u8) ^ byte) as usize]
740 }
741
742 const CRC8_TABLE: [u8; 256] = [
743 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
744 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
745 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
746 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
747 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
748 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
749 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
750 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
751 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
752 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
753 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
754 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
755 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
756 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
757 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
758 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
759 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
760 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
761 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
762 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
763 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
764 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
765 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
766 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
767 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
768 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
769 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
770 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
771 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
772 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
773 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
774 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
775 ];
776
777 const CRC16_TABLE: [u16; 256] = [
778 0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011,
779 0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022,
780 0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072,
781 0x0050, 0x8055, 0x805F, 0x005A, 0x804B, 0x004E, 0x0044, 0x8041,
782 0x80C3, 0x00C6, 0x00CC, 0x80C9, 0x00D8, 0x80DD, 0x80D7, 0x00D2,
783 0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB, 0x00EE, 0x00E4, 0x80E1,
784 0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE, 0x00B4, 0x80B1,
785 0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087, 0x0082,
786 0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192,
787 0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1,
788 0x01E0, 0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1,
789 0x81D3, 0x01D6, 0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2,
790 0x0140, 0x8145, 0x814F, 0x014A, 0x815B, 0x015E, 0x0154, 0x8151,
791 0x8173, 0x0176, 0x017C, 0x8179, 0x0168, 0x816D, 0x8167, 0x0162,
792 0x8123, 0x0126, 0x012C, 0x8129, 0x0138, 0x813D, 0x8137, 0x0132,
793 0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E, 0x0104, 0x8101,
794 0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317, 0x0312,
795 0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321,
796 0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371,
797 0x8353, 0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342,
798 0x03C0, 0x83C5, 0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1,
799 0x83F3, 0x03F6, 0x03FC, 0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2,
800 0x83A3, 0x03A6, 0x03AC, 0x83A9, 0x03B8, 0x83BD, 0x83B7, 0x03B2,
801 0x0390, 0x8395, 0x839F, 0x039A, 0x838B, 0x038E, 0x0384, 0x8381,
802 0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E, 0x0294, 0x8291,
803 0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7, 0x02A2,
804 0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2,
805 0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1,
806 0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252,
807 0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261,
808 0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231,
809 0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202
810 ];