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 | |
| 6 | use oxedyne_fe2o3_graphics::running; |
| 7 | |
| 8 | use 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. |
| 15 | fn millis(b: &[u8]) -> Option<u64> { |
| 16 | match running::millis(b) { |
| 17 | Ok(m) => m, |
| 18 | Err(e) => panic!("{}", e), |
| 19 | } |
| 20 | } |
| 21 | |
| 22 | fn 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] |
| 36 | fn 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] |
| 43 | fn 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 | |
| 55 | fn 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] |
| 66 | fn 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 | |
| 79 | fn 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] |
| 87 | fn 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] |
| 106 | fn 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] |
| 125 | fn 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 | } |