Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_graphics/tests/running.rs

4.9 KiB, 1 run

created by r2953280680:79567, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1//! Is a sound's running time read from its header, for each format, and none where the header states none?
2//!
3//! Each file is built here to the format's specification; `RUNNING_CORPUS` names a folder of real files to compare
4//! with ffprobe as well.
5
6use oxedyne_fe2o3_graphics::running;
7
8use std::{
9 env,
10 fs,
11 process::Command,
12};
13
14// The length read, a header cut short failing the test in the reader's words.
15fn millis(b: &[u8]) -> Option<u64> {
16 match running::millis(b) {
17 Ok(m) => m,
18 Err(e) => panic!("{}", e),
19 }
20}
21
22fn wav(secs: u32, rate: u32, streaming: bool) -> Vec<u8> {
23 let data = rate * 2 * secs; // 16-bit mono
24 let mut b = b"RIFF\0\0\0\0WAVE".to_vec();
25 b.extend_from_slice(b"LIST\x03\0\0\0abc\0"); // an odd chunk, padded
26 b.extend_from_slice(b"fmt \x10\0\0\0\x01\0\x01\0");
27 b.extend_from_slice(&rate.to_le_bytes());
28 b.extend_from_slice(&(rate * 2).to_le_bytes());
29 b.extend_from_slice(b"\x02\0\x10\0data");
30 b.extend_from_slice(&if streaming { u32::MAX } else { data }.to_le_bytes());
31 b.resize(b.len() + data as usize, 0);
32 b
33}
34
35#[test]
36fn wav_by_its_byte_rate() {
37 assert_eq!(millis(&wav(20, 16_000, false)), Some(20_000));
38 assert_eq!(millis(&wav(3, 8_000, true)), Some(3_000));
39 assert_eq!(millis(&b"RIFF\0\0\0\0WAVEdata\0\0\0\0".to_vec()), None); // no fmt chunk
40}
41
42#[test]
43fn flac_by_streaminfo() {
44 let mut b = b"fLaC\x00\x00\x00\x22".to_vec();
45 b.extend_from_slice(&[0; 10]);
46 let x: u64 = (44_100 << 44) | (1 << 41) | (15 << 36) | 441_000; // 44.1 kHz, stereo, 16 bits, 10 s
47 b.extend_from_slice(&x.to_be_bytes());
48 b.extend_from_slice(&[0; 16]);
49 assert_eq!(millis(&b), Some(10_000));
50 b[21] &= 0xF0;
51 b[22..26].copy_from_slice(&[0; 4]);
52 assert_eq!(millis(&b), None); // a count of nought
53}
54
55fn page(granule: i64, packet: &[u8]) -> Vec<u8> {
56 let mut b = b"OggS\0\0".to_vec();
57 b.extend_from_slice(&granule.to_le_bytes());
58 b.extend_from_slice(&[0; 12]);
59 b.push(1);
60 b.push(packet.len() as u8);
61 b.extend_from_slice(packet);
62 b
63}
64
65#[test]
66fn ogg_by_its_last_granule() {
67 let mut id = b"\x01vorbis\0\0\0\0\x02".to_vec();
68 id.extend_from_slice(&48_000u32.to_le_bytes());
69 let mut b = page(0, &id);
70 b.extend(page(96_000, b"audio"));
71 b.extend(page(240_000, b"audio"));
72 assert_eq!(millis(&b), Some(5_000));
73 let mut b = page(0, b"OpusHead\x01\x02\x38\x01\x80\xbb\0\0\0\0\0"); // a pre-skip of 312
74 b.extend(page(480_312, b"audio"));
75 assert_eq!(millis(&b), Some(10_000));
76 assert_eq!(millis(&page(0, b"\x80theora...")), None);
77}
78
79fn bx(kind: &[u8], body: &[u8]) -> Vec<u8> {
80 let mut b = ((body.len() + 8) as u32).to_be_bytes().to_vec();
81 b.extend_from_slice(kind);
82 b.extend_from_slice(body);
83 b
84}
85
86#[test]
87fn mp4_by_mvhd() {
88 let mut v0 = vec![0; 12];
89 v0.extend_from_slice(&600u32.to_be_bytes());
90 v0.extend_from_slice(&(600u32 * 75 / 2).to_be_bytes()); // 37.5 s
91 let mut b = bx(b"ftyp", b"M4A \0\0\0\0");
92 b.extend(bx(b"mdat", &[0; 64]));
93 b.extend(bx(b"moov", &bx(b"mvhd", &v0)));
94 assert_eq!(millis(&b), Some(37_500));
95 let mut v1 = vec![1, 0, 0, 0];
96 v1.extend_from_slice(&[0; 16]);
97 v1.extend_from_slice(&1000u32.to_be_bytes());
98 v1.extend_from_slice(&7_200_000u64.to_be_bytes()); // two hours
99 let mut b = bx(b"ftyp", b"isom\0\0\0\0");
100 b.extend(bx(b"moov", &[bx(b"udta", &[]), bx(b"mvhd", &v1)].concat()));
101 assert_eq!(millis(&b), Some(7_200_000));
102 assert_eq!(millis(&bx(b"ftyp", b"isom\0\0\0\0")), None);
103}
104
105#[test]
106fn mp3_by_its_frame_count_or_bit_rate() {
107 // MPEG-1 Layer III, 128 kbps, 44.1 kHz, stereo.
108 let head = [0xFF, 0xFB, 0x90, 0x00];
109 let mut cbr = b"ID3\x04\0\0\0\0\0\x0a".to_vec();
110 cbr.extend_from_slice(&[0; 10]);
111 cbr.extend_from_slice(&head);
112 cbr.resize(cbr.len() - 4 + 160_000, 0); // 160,000 bytes at 16,000 a second
113 assert_eq!(millis(&cbr), Some(10_000));
114 let mut xing = head.to_vec();
115 xing.extend_from_slice(&[0; 32]);
116 xing.extend_from_slice(b"Xing\0\0\0\x01");
117 xing.extend_from_slice(&3_828u32.to_be_bytes()); // 3,828 frames of 1,152 samples: 99.99 s
118 xing.resize(4_000, 0);
119 assert_eq!(millis(&xing), Some(99_996));
120 assert_eq!(millis(b"plain text, no sound"), None);
121}
122
123// Each file of the corpus that ffprobe gives a length is read within a tenth of a second of it, or one part in a hundred.
124#[test]
125fn corpus_agrees_with_ffprobe() {
126 let Ok(dir) = env::var("RUNNING_CORPUS") else { return };
127 let mut n = 0;
128 for e in fs::read_dir(&dir).into_iter().flatten().flatten() {
129 let p = e.path();
130 let out = Command::new("ffprobe").args(["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0"]).arg(&p).output();
131 let Some(want) = out.ok().and_then(|o| String::from_utf8(o.stdout).ok()).and_then(|s| s.trim().parse::<f64>().ok()) else { continue };
132 let got = fs::read(&p).ok().and_then(|b| running::millis(&b).ok().flatten()).map(|m| m as f64 / 1000.0);
133 let off = got.map(|g| (g - want).abs());
134 println!("{}\t{:?}\t{}", p.display(), got, want);
135 assert!(off.is_some_and(|o| o <= (want / 100.0).max(0.1)), "{} reads {:?}, ffprobe {}", p.display(), got, want);
136 n += 1;
137 }
138 assert!(n > 0, "RUNNING_CORPUS {} holds no file ffprobe reads", dir);
139}