From 765c7011c257b541816be1a4ec1e6c45d3b8b065 Mon Sep 17 00:00:00 2001
From: Casey Rodarmor <casey@rodarmor.com>
Date: Wed, 5 Aug 2026 22:31:06 -0700
Subject: [PATCH] Calculate audio bitrate

---
 src/audio.rs                  | 60 ++++++++++++++++++++++++++---
 src/audio_error.rs            |  2 +
 src/audio_metadata.rs         |  1 +
 src/display_bitrate.rs        | 21 ++++++++--
 src/flac_decoder.rs           | 72 ++++++++++++++++++++++++++++-------
 src/metadata.rs               |  1 +
 src/mp3_decoder.rs            | 25 ++++++++----
 src/subcommand/serve/tests.rs |  2 +
 src/templates/audio.rs        |  1 +
 src/templates/package.rs      |  6 +++
 src/test.rs                   |  2 +
 src/track.rs                  | 18 +--------
 tests/metadata.rs             |  3 ++
 13 files changed, 169 insertions(+), 45 deletions(-)

diff --git a/src/audio.rs b/src/audio.rs
index 222f0638..788bb4ca 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -22,12 +22,14 @@ pub(crate) struct Audio {
   #[n(8)]
   pub(crate) samples: u64,
   #[n(9)]
-  pub(crate) title: Text,
+  pub(crate) size: u64,
   #[n(10)]
-  pub(crate) track: u64,
+  pub(crate) title: Text,
   #[n(11)]
-  pub(crate) tracks: u64,
+  pub(crate) track: u64,
   #[n(12)]
+  pub(crate) tracks: u64,
+  #[n(13)]
   #[serde(rename = "type")]
   pub(crate) ty: AudioType,
 }
@@ -162,6 +164,7 @@ impl Audio {
       sample_bits,
       sample_rate,
       samples,
+      size,
       title,
       track,
       tracks,
@@ -175,6 +178,7 @@ impl Audio {
     self.sample_bits = sample_bits;
     self.sample_rate = sample_rate;
     self.samples = samples;
+    self.size = size;
     self.title = title;
     self.track = track;
     self.tracks = tracks;
@@ -234,6 +238,7 @@ impl FromStr for Audio {
       sample_bits: None,
       sample_rate: 0,
       samples: 0,
+      size: 0,
       title: Text::new(),
       track: 0,
       tracks: 0,
@@ -260,6 +265,13 @@ impl Item for Audio {
           .map(|sample_bits| format!("{sample_bits}-bit")),
       )
       .value("sample rate", DisplaySampleRate(self.sample_rate))
+      .optional(
+        "bit rate",
+        DisplayBitrate::new(
+          u64::try_from(self.duration().as_millis()).unwrap_or(u64::MAX),
+          self.size,
+        ),
+      )
       .value("channels", self.channels)
       .value(
         "compression mode",
@@ -470,6 +482,7 @@ mod tests {
         sample_bits: None,
         sample_rate: 0,
         samples: 0,
+        size: 0,
         title: Text::new(),
         track: 0,
         tracks: 0,
@@ -489,6 +502,7 @@ mod tests {
         sample_bits: None,
         sample_rate: 0,
         samples: 0,
+        size: 0,
         title: Text::new(),
         track: 0,
         tracks: 0,
@@ -523,6 +537,7 @@ mod tests {
     audio.sample_bits = Some(16);
     audio.sample_rate = 44100;
     audio.samples = 66150;
+    audio.size = 750;
     audio.title = "bar".parse().unwrap();
     audio.track = 3;
     audio.tracks = 4;
@@ -546,6 +561,7 @@ mod tests {
         ("type".into(), Info::Value("FLAC".into())),
         ("sample bits".into(), Info::Value("16-bit".into())),
         ("sample rate".into(), Info::Value("44.1 kHz".into())),
+        ("bit rate".into(), Info::Value("4 kbit/s".into())),
         ("channels".into(), Info::Value("2".into())),
         ("compression mode".into(), Info::Value("lossless".into())),
         ("samples".into(), Info::Value("66150".into())),
@@ -560,6 +576,7 @@ mod tests {
     audio.discs = 2;
     audio.sample_rate = 44100;
     audio.samples = 66150;
+    audio.size = 750;
     audio.title = "bar".parse().unwrap();
     audio.track = 3;
     audio.tracks = 4;
@@ -582,11 +599,39 @@ mod tests {
         ("duration".into(), Info::Value("0:01".into())),
         ("type".into(), Info::Value("MP3".into())),
         ("sample rate".into(), Info::Value("44.1 kHz".into())),
+        ("bit rate".into(), Info::Value("4 kbit/s".into())),
         ("channels".into(), Info::Value("2".into())),
         ("compression mode".into(), Info::Value("lossy".into())),
         ("samples".into(), Info::Value("66150".into())),
       ]),
     );
+
+    let mut audio = "foo.flac".parse::<Audio>().unwrap();
+    audio.size = 750;
+
+    assert_eq!(
+      Item::info(&audio, "bob".into()),
+      Info::Map(vec![
+        (
+          "filename".into(),
+          Info::Link {
+            text: "foo.flac".into(),
+            url: "bob".into(),
+          },
+        ),
+        ("title".into(), Info::Value(String::new())),
+        ("artist".into(), Info::Value(String::new())),
+        ("album".into(), Info::Value(String::new())),
+        ("disc".into(), Info::Value("0 of 0".into())),
+        ("track".into(), Info::Value("0 of 0".into())),
+        ("duration".into(), Info::Value("0:00".into())),
+        ("type".into(), Info::Value("FLAC".into())),
+        ("sample rate".into(), Info::Value("0 kHz".into())),
+        ("channels".into(), Info::Value("0".into())),
+        ("compression mode".into(), Info::Value("lossless".into())),
+        ("samples".into(), Info::Value("0".into())),
+      ]),
+    );
   }
 
   #[test]
@@ -634,6 +679,7 @@ mod tests {
         sample_bits: Some(16),
         sample_rate: 44100,
         samples: 66150,
+        size: 1024,
         title: "bar".parse().unwrap(),
         track: 3,
         tracks: 4,
@@ -656,6 +702,7 @@ mod tests {
         sample_bits: None,
         sample_rate: 44100,
         samples: 2304,
+        size: 834,
         title: "bar".parse().unwrap(),
         track: 3,
         tracks: 4,
@@ -668,12 +715,12 @@ mod tests {
   fn serialize() {
     assert_eq!(
       serde_json::to_string(&"foo.flac".parse::<Audio>().unwrap()).unwrap(),
-      r#"{"album":"","artist":"","channels":0,"disc":0,"discs":0,"filename":"foo.flac","sample_rate":0,"samples":0,"title":"","track":0,"tracks":0,"type":"flac"}"#,
+      r#"{"album":"","artist":"","channels":0,"disc":0,"discs":0,"filename":"foo.flac","sample_rate":0,"samples":0,"size":0,"title":"","track":0,"tracks":0,"type":"flac"}"#,
     );
 
     assert_eq!(
       serde_json::to_string(&"foo.mp3".parse::<Audio>().unwrap()).unwrap(),
-      r#"{"album":"","artist":"","channels":0,"disc":0,"discs":0,"filename":"foo.mp3","sample_rate":0,"samples":0,"title":"","track":0,"tracks":0,"type":"mp3"}"#,
+      r#"{"album":"","artist":"","channels":0,"disc":0,"discs":0,"filename":"foo.mp3","sample_rate":0,"samples":0,"size":0,"title":"","track":0,"tracks":0,"type":"mp3"}"#,
     );
 
     assert_eq!(
@@ -687,13 +734,14 @@ mod tests {
         sample_bits: Some(7),
         sample_rate: 1,
         samples: 2,
+        size: 9,
         title: "bar".parse().unwrap(),
         track: 5,
         tracks: 6,
         ty: AudioType::Flac,
       })
       .unwrap(),
-      r#"{"album":"qux","artist":"baz","channels":8,"disc":3,"discs":4,"filename":"foo.flac","sample_bits":7,"sample_rate":1,"samples":2,"title":"bar","track":5,"tracks":6,"type":"flac"}"#,
+      r#"{"album":"qux","artist":"baz","channels":8,"disc":3,"discs":4,"filename":"foo.flac","sample_bits":7,"sample_rate":1,"samples":2,"size":9,"title":"bar","track":5,"tracks":6,"type":"flac"}"#,
     );
   }
 }
diff --git a/src/audio_error.rs b/src/audio_error.rs
index 30c4053f..d7539e08 100644
--- a/src/audio_error.rs
+++ b/src/audio_error.rs
@@ -7,6 +7,8 @@ pub enum AudioError {
   FlacDecode { source: claxon::Error },
   #[snafu(display("unknown sample count"))]
   FlacSampleCountUnknown,
+  #[snafu(display("truncated FLAC metadata block"))]
+  FlacTruncated,
   #[snafu(display("failed to decode MP3"))]
   Mp3Decode { source: Mp3Error },
   #[snafu(display("failed to read ID3 tag"))]
diff --git a/src/audio_metadata.rs b/src/audio_metadata.rs
index 82035f43..4827d017 100644
--- a/src/audio_metadata.rs
+++ b/src/audio_metadata.rs
@@ -10,6 +10,7 @@ pub(crate) struct AudioMetadata {
   pub(crate) sample_bits: Option<u64>,
   pub(crate) sample_rate: u64,
   pub(crate) samples: u64,
+  pub(crate) size: u64,
   pub(crate) title: Text,
   pub(crate) track: u64,
   pub(crate) tracks: u64,
diff --git a/src/display_bitrate.rs b/src/display_bitrate.rs
index db64c41c..f056ca49 100644
--- a/src/display_bitrate.rs
+++ b/src/display_bitrate.rs
@@ -1,8 +1,14 @@
 use super::*;
 
 pub(crate) struct DisplayBitrate {
-  pub(crate) duration: u64,
-  pub(crate) size: u64,
+  duration: u64,
+  size: u64,
+}
+
+impl DisplayBitrate {
+  pub(crate) fn new(duration: u64, size: u64) -> Option<Self> {
+    (duration > 0).then_some(Self { duration, size })
+  }
 }
 
 impl Display for DisplayBitrate {
@@ -32,7 +38,10 @@ mod tests {
   fn display() {
     #[track_caller]
     fn case(size: u64, duration: u64, expected: &str) {
-      assert_eq!(DisplayBitrate { duration, size }.to_string(), expected);
+      assert_eq!(
+        DisplayBitrate::new(duration, size).unwrap().to_string(),
+        expected,
+      );
     }
 
     case(0, 1000, "0 bits/s");
@@ -44,4 +53,10 @@ mod tests {
     case(437_500, 1000, "3.5 Mbit/s");
     case(125_000_000, 1000, "1 Gbit/s");
   }
+
+  #[test]
+  fn new() {
+    assert!(DisplayBitrate::new(0, 1).is_none());
+    assert!(DisplayBitrate::new(1, 1).is_some());
+  }
 }
diff --git a/src/flac_decoder.rs b/src/flac_decoder.rs
index ae65e7dd..a63edf3a 100644
--- a/src/flac_decoder.rs
+++ b/src/flac_decoder.rs
@@ -1,13 +1,13 @@
 use super::*;
 
-pub(crate) struct FlacDecoder<T: io::Read> {
-  reader: FlacReader<T>,
+pub(crate) struct FlacDecoder<'a> {
+  reader: FlacReader<&'a [u8]>,
 }
 
-impl<T: io::Read> FlacDecoder<T> {
-  fn decode(reader: T) -> Result<AudioMetadata, AudioError> {
+impl<'a> FlacDecoder<'a> {
+  fn decode(data: &'a [u8]) -> Result<AudioMetadata, AudioError> {
     let decoder = Self {
-      reader: FlacReader::new(reader).context(audio_error::FlacDecode)?,
+      reader: FlacReader::new(data).context(audio_error::FlacDecode)?,
     };
 
     let streaminfo = decoder.reader.streaminfo();
@@ -25,17 +25,45 @@ impl<T: io::Read> FlacDecoder<T> {
       sample_bits: Some(streaminfo.bits_per_sample.into()),
       sample_rate: streaminfo.sample_rate.into(),
       samples,
+      size: (data.len() - Self::frame_offset(data)?).into_u64(),
       title: decoder.text_tag("title")?,
       track: decoder.number_tag("tracknumber")?,
       tracks: decoder.number_tag("tracktotal")?,
     })
   }
 
+  fn frame_offset(data: &[u8]) -> Result<usize, AudioError> {
+    let mut offset = 4;
+
+    loop {
+      let header = data
+        .get(offset..offset + 4)
+        .context(audio_error::FlacTruncated)?;
+
+      let length =
+        usize::from(header[1]) << 16 | usize::from(header[2]) << 8 | usize::from(header[3]);
+
+      offset += 4 + length;
+
+      ensure!(offset <= data.len(), audio_error::FlacTruncated);
+
+      if header[0] & 0x80 != 0 {
+        return Ok(offset);
+      }
+    }
+  }
+
   fn number_tag(&self, tag: &'static str) -> Result<u64, AudioError> {
     let value = self.tag(tag)?;
     parse_number(value).context(audio_error::TagInteger { tag })
   }
 
+  pub(crate) fn read(path: &Utf8Path) -> Result<AudioMetadata> {
+    let data = filesystem::read(path)?;
+
+    FlacDecoder::decode(&data).context(error::Audio { path })
+  }
+
   fn tag(&self, tag: &'static str) -> Result<&str, AudioError> {
     Audio::tag(self.reader.get_tag(tag), tag)
   }
@@ -48,14 +76,6 @@ impl<T: io::Read> FlacDecoder<T> {
   }
 }
 
-impl FlacDecoder<fs::File> {
-  pub(crate) fn read(path: &Utf8Path) -> Result<AudioMetadata> {
-    let file = filesystem::open(path)?;
-
-    Self::decode(file).context(error::Audio { path })
-  }
-}
-
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -246,6 +266,31 @@ mod tests {
     );
   }
 
+  #[test]
+  fn frame_offset() {
+    let bytes = flac(&[], 44100);
+    assert_eq!(
+      FlacDecoder::frame_offset(&bytes).unwrap(),
+      bytes.len() - 1024,
+    );
+
+    let bytes = flac(&["foo=bar"], 44100);
+    assert_eq!(
+      FlacDecoder::frame_offset(&bytes).unwrap(),
+      bytes.len() - 1024,
+    );
+
+    assert_matches!(
+      FlacDecoder::frame_offset(b"fLaC"),
+      Err(AudioError::FlacTruncated),
+    );
+
+    assert_matches!(
+      FlacDecoder::frame_offset(&[b"fLaC".as_slice(), &[0x80, 0x00, 0x00, 0x22]].concat()),
+      Err(AudioError::FlacTruncated),
+    );
+  }
+
   #[test]
   fn read_ok() {
     let (_tempdir, root) = tempdir();
@@ -280,6 +325,7 @@ mod tests {
         sample_bits: Some(16),
         sample_rate: 44100,
         samples: 66150,
+        size: 1024,
         title: "bar".parse().unwrap(),
         track: 3,
         tracks: 4,
diff --git a/src/metadata.rs b/src/metadata.rs
index bfbac743..51515ce6 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -419,6 +419,7 @@ mod tests {
           sample_bits: Some(7),
           sample_rate: 1,
           samples: 2,
+          size: 9,
           title: "foo".parse().unwrap(),
           track: 5,
           tracks: 6,
diff --git a/src/mp3_decoder.rs b/src/mp3_decoder.rs
index 032a7f85..12866d09 100644
--- a/src/mp3_decoder.rs
+++ b/src/mp3_decoder.rs
@@ -13,6 +13,7 @@ struct AudioProperties {
   channels: u64,
   sample_rate: u64,
   samples: u64,
+  size: u64,
 }
 
 struct Frame {
@@ -65,12 +66,14 @@ impl<'a> Mp3Decoder<'a> {
     let mut offset = 0;
     let mut first = Option::<Frame>::None;
     let mut samples = 0;
+    let mut size = 0;
 
     while offset < decoder.data.len() {
       let frame = decoder.frame(offset)?;
 
       if !frame.metadata {
         samples += frame.samples;
+        size += frame.size.into_u64();
       }
 
       offset += frame.size;
@@ -108,6 +111,7 @@ impl<'a> Mp3Decoder<'a> {
       channels,
       sample_rate,
       samples,
+      size,
     })
   }
 
@@ -205,6 +209,7 @@ impl<'a> Mp3Decoder<'a> {
       channels,
       sample_rate,
       samples,
+      size,
     } = Mp3Decoder::decode(&data[start..]).context(audio_error::Mp3Decode)?;
 
     Ok(AudioMetadata {
@@ -216,6 +221,7 @@ impl<'a> Mp3Decoder<'a> {
       sample_bits: None,
       sample_rate,
       samples,
+      size,
       title,
       track,
       tracks,
@@ -276,11 +282,12 @@ mod tests {
       bytes
     }
 
-    fn properties(channels: u64, sample_rate: u64, samples: u64) -> AudioProperties {
+    fn properties(channels: u64, sample_rate: u64, samples: u64, size: u64) -> AudioProperties {
       AudioProperties {
         channels,
         sample_rate,
         samples,
+        size,
       }
     }
 
@@ -296,31 +303,34 @@ mod tests {
       bytes
     };
 
-    case(&[mp3_frame(), mp3_frame()], Ok(properties(2, 44100, 2304)));
+    case(
+      &[mp3_frame(), mp3_frame()],
+      Ok(properties(2, 44100, 2304, 834)),
+    );
 
     case(
       &[xing(), mp3_frame(), mp3_frame()],
-      Ok(properties(2, 44100, 2304)),
+      Ok(properties(2, 44100, 2304, 834)),
     );
 
     case(
       &[frame([0xFF, 0xFB, 0x92, 0x00], 418), mp3_frame()],
-      Ok(properties(2, 44100, 2304)),
+      Ok(properties(2, 44100, 2304, 835)),
     );
 
     case(
       &[frame([0xFF, 0xFB, 0x90, 0xC0], 417)],
-      Ok(properties(1, 44100, 1152)),
+      Ok(properties(1, 44100, 1152, 417)),
     );
 
     case(
       &[frame([0xFF, 0xF3, 0x90, 0x00], 261)],
-      Ok(properties(2, 22050, 576)),
+      Ok(properties(2, 22050, 576, 261)),
     );
 
     case(
       &[frame([0xFF, 0xE3, 0x90, 0x00], 522)],
-      Ok(properties(2, 11025, 576)),
+      Ok(properties(2, 11025, 576, 522)),
     );
 
     case(&[], Err(Mp3Error::Empty));
@@ -494,6 +504,7 @@ mod tests {
         sample_bits: None,
         sample_rate: 44100,
         samples: 2304,
+        size: 834,
         title: "bar".parse().unwrap(),
         track: 3,
         tracks: 4,
diff --git a/src/subcommand/serve/tests.rs b/src/subcommand/serve/tests.rs
index 631e4176..50ed9bfa 100644
--- a/src/subcommand/serve/tests.rs
+++ b/src/subcommand/serve/tests.rs
@@ -1863,6 +1863,7 @@ fn package_page_renders_audio_media() {
           sample_bits: Some(16),
           sample_rate: 44100,
           samples: 9_922_500,
+          size: 0,
           title: "foo".parse().unwrap(),
           track: 1,
           tracks: 2,
@@ -1878,6 +1879,7 @@ fn package_page_renders_audio_media() {
           sample_bits: Some(16),
           sample_rate: 44100,
           samples: 44100,
+          size: 0,
           title: "bar".parse().unwrap(),
           track: 2,
           tracks: 2,
diff --git a/src/templates/audio.rs b/src/templates/audio.rs
index 196e5a9c..dee075e0 100644
--- a/src/templates/audio.rs
+++ b/src/templates/audio.rs
@@ -45,6 +45,7 @@ mod tests {
           sample_bits: Some(16),
           sample_rate: 44100,
           samples: 9_922_500,
+          size: 0,
           title: "foo".parse().unwrap(),
           track: 1,
           tracks: 1,
diff --git a/src/templates/package.rs b/src/templates/package.rs
index 6801c3b9..710da994 100644
--- a/src/templates/package.rs
+++ b/src/templates/package.rs
@@ -62,6 +62,7 @@ mod tests {
             sample_bits: Some(16),
             sample_rate: 44100,
             samples: 9_922_500,
+            size: 0,
             title: "foo".parse().unwrap(),
             track: 1,
             tracks: 2,
@@ -77,6 +78,7 @@ mod tests {
             sample_bits: Some(24),
             sample_rate: 96000,
             samples: 96000,
+            size: 0,
             title: "bar".parse().unwrap(),
             track: 2,
             tracks: 2,
@@ -154,6 +156,7 @@ mod tests {
             sample_bits: Some(16),
             sample_rate: 44100,
             samples: 44100,
+            size: 0,
             title: "foo".parse().unwrap(),
             track: 1,
             tracks: 2,
@@ -169,6 +172,7 @@ mod tests {
             sample_bits: Some(16),
             sample_rate: 44100,
             samples: 44100,
+            size: 0,
             title: "bar".parse().unwrap(),
             track: 2,
             tracks: 2,
@@ -184,6 +188,7 @@ mod tests {
             sample_bits: Some(16),
             sample_rate: 44100,
             samples: 44100,
+            size: 0,
             title: "baz".parse().unwrap(),
             track: 1,
             tracks: 1,
@@ -266,6 +271,7 @@ mod tests {
       sample_bits: Some(16),
       sample_rate: 1,
       samples: u64::MAX,
+      size: 0,
       title: "foo".parse().unwrap(),
       track: 1,
       tracks: 2,
diff --git a/src/test.rs b/src/test.rs
index fe3d8743..437cde40 100644
--- a/src/test.rs
+++ b/src/test.rs
@@ -127,6 +127,8 @@ pub(crate) fn flac(comments: &[&str], samples: u32) -> Vec<u8> {
     bytes.extend(body);
   }
 
+  bytes.extend_from_slice(&[0; 1024]);
+
   bytes
 }
 
diff --git a/src/track.rs b/src/track.rs
index b2620752..22efc1e2 100644
--- a/src/track.rs
+++ b/src/track.rs
@@ -29,14 +29,7 @@ impl Track {
       } => builder
         .value("channels", channels)
         .value("sample rate", DisplaySampleRate(sample_rate))
-        .when(
-          video.duration > 0,
-          "bit rate",
-          DisplayBitrate {
-            duration: video.duration,
-            size: self.size,
-          },
-        ),
+        .optional("bit rate", DisplayBitrate::new(video.duration, self.size)),
       TrackInfo::Video {
         bit_depth,
         chroma_subsampling,
@@ -59,14 +52,7 @@ impl Track {
               frames,
             },
           )
-          .when(
-            video.duration > 0,
-            "bit rate",
-            DisplayBitrate {
-              duration: video.duration,
-              size: self.size,
-            },
-          )
+          .optional("bit rate", DisplayBitrate::new(video.duration, self.size))
           .when(
             pixels > 0,
             "bits per pixel",
diff --git a/tests/metadata.rs b/tests/metadata.rs
index 07c85d38..6b94108b 100644
--- a/tests/metadata.rs
+++ b/tests/metadata.rs
@@ -177,6 +177,7 @@ fn create_extracts_track_tags() {
                 "sample_bits": 16,
                 "sample_rate": 44100,
                 "samples": 44100,
+                "size": 1024,
                 "title": "bar",
                 "track": 1,
                 "tracks": 1,
@@ -503,6 +504,8 @@ fn flac(comments: &[&str], samples: u32) -> Vec<u8> {
     bytes.extend(body);
   }
 
+  bytes.extend_from_slice(&[0; 1024]);
+
   bytes
 }