From e4c619b84c3b4e3a91d242d3e86a29a274988e0a Mon Sep 17 00:00:00 2001
From: Casey Rodarmor <casey@rodarmor.com>
Date: Mon, 24 Aug 2026 20:09:21 -0700
Subject: [PATCH 1/2] Extract titles from videos

---
 src/item.rs              |  24 +++++++-
 src/metadata.rs          |   2 +-
 src/mp4_builder.rs       |  34 +++++++++++-
 src/mp4_decoder.rs       |  65 ++++++++++++++++++++--
 src/templates/package.rs |   4 +-
 src/templates/video.rs   |  31 ++++++++++-
 src/video.rs             |  12 ++--
 src/video_error.rs       |  16 ++++++
 src/video_metadata.rs    |   1 +
 src/webm_builder.rs      |  56 +++++++++++++++++++
 src/webm_decoder.rs      | 115 +++++++++++++++++++++++++++++++++++++--
 templates/package.html   |   2 +-
 tests/metadata.rs        |   4 +-
 13 files changed, 346 insertions(+), 20 deletions(-)

diff --git a/src/item.rs b/src/item.rs
index 871920fc..26a89711 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -25,6 +25,13 @@ impl Item<Audio> {
   }
 }
 
+impl Item<Video> {
+  pub(crate) fn populate(&mut self, root: &Utf8Path) -> Result {
+    self.title = self.content.populate(root)?;
+    Ok(())
+  }
+}
+
 impl<T: Content> MediaItem for Item<T> {
   fn info(&self, url: String) -> Info {
     self
@@ -142,7 +149,7 @@ mod tests {
   }
 
   #[test]
-  fn populate() {
+  fn populate_audio() {
     let (_tempdir, root) = tempdir();
 
     std::fs::write(
@@ -164,4 +171,19 @@ mod tests {
     item.populate(&root).unwrap();
     assert_eq!(item.title, Some("bar".parse().unwrap()));
   }
+
+  #[test]
+  fn populate_video() {
+    let (_tempdir, root) = tempdir();
+
+    std::fs::write(
+      root.join("foo.mp4"),
+      Mp4Builder::new().video_track(2, 1).name("bar").build(),
+    )
+    .unwrap();
+
+    let mut item = "foo.mp4".parse::<Item<Video>>().unwrap();
+    item.populate(&root).unwrap();
+    assert_eq!(item.title, Some("bar".parse().unwrap()));
+  }
 }
diff --git a/src/metadata.rs b/src/metadata.rs
index d42dfcf7..ef3d5e0c 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -281,7 +281,7 @@ impl Metadata {
         }
         Media::Video { items } => {
           for video in items {
-            video.content.populate(root)?;
+            video.populate(root)?;
             bar.inc(1);
           }
         }
diff --git a/src/mp4_builder.rs b/src/mp4_builder.rs
index 17d2f36d..5b812c6c 100644
--- a/src/mp4_builder.rs
+++ b/src/mp4_builder.rs
@@ -3,6 +3,7 @@ pub struct Mp4Builder {
   duration: u32,
   frame_count: u32,
   matrix: [i32; 9],
+  name: Option<Vec<u8>>,
   sample_size: u32,
   sample_sizes: Vec<u32>,
   sps: Vec<u8>,
@@ -66,7 +67,31 @@ impl Mp4Builder {
     mvhd.extend_from_slice(&0x0001_0000u32.to_be_bytes());
     mvhd.extend_from_slice(&[0; 76]);
 
-    let moov = [Self::atom(*b"mvhd", &mvhd), self.tracks.concat()].concat();
+    let udta = self
+      .name
+      .as_ref()
+      .map(|name| {
+        let mut hdlr = vec![0; 8];
+        hdlr.extend_from_slice(b"mdir");
+        hdlr.extend_from_slice(&[0; 12]);
+        hdlr.push(0);
+
+        let mut data = 1u32.to_be_bytes().to_vec();
+        data.extend_from_slice(&[0; 4]);
+        data.extend_from_slice(name);
+
+        let ilst = Self::atom(
+          *b"ilst",
+          &Self::atom(*b"\xa9nam", &Self::atom(*b"data", &data)),
+        );
+
+        let meta = [vec![0; 4], Self::atom(*b"hdlr", &hdlr), ilst].concat();
+
+        Self::atom(*b"udta", &Self::atom(*b"meta", &meta))
+      })
+      .unwrap_or_default();
+
+    let moov = [Self::atom(*b"mvhd", &mvhd), self.tracks.concat(), udta].concat();
 
     [Self::atom(*b"ftyp", &ftyp), Self::atom(*b"moov", &moov)].concat()
   }
@@ -89,12 +114,19 @@ impl Mp4Builder {
     self
   }
 
+  #[must_use]
+  pub fn name(mut self, name: impl AsRef<[u8]>) -> Self {
+    self.name = Some(name.as_ref().into());
+    self
+  }
+
   pub fn new() -> Self {
     Self {
       avcc_profile: 0,
       duration: 0,
       frame_count: 0,
       matrix: [0x0001_0000, 0, 0, 0, 0x0001_0000, 0, 0, 0, 0x4000_0000],
+      name: None,
       sample_size: 1,
       sample_sizes: Vec::new(),
       sps: Vec::new(),
diff --git a/src/mp4_decoder.rs b/src/mp4_decoder.rs
index 6f8c7244..83a1f257 100644
--- a/src/mp4_decoder.rs
+++ b/src/mp4_decoder.rs
@@ -1,4 +1,7 @@
-use super::*;
+use {
+  super::*,
+  re_mp4::{MetaBox, MetadataKey, Mp4, Mp4aBox, StsdBoxContent, TkhdBox},
+};
 
 pub(crate) struct Mp4Decoder;
 
@@ -67,8 +70,6 @@ impl Mp4Decoder {
   }
 
   fn metadata<T: Read + Seek>(reader: T, size: u64) -> Result<VideoMetadata, VideoError> {
-    use re_mp4::{Mp4, Mp4aBox, StsdBoxContent, TkhdBox};
-
     fn mp4a_codec(mp4a: &Mp4aBox) -> Option<Codec> {
       match mp4a
         .esds
@@ -245,7 +246,13 @@ impl Mp4Decoder {
       tracks.push(track);
     }
 
-    Ok(VideoMetadata { duration, tracks })
+    let title = Self::title(&mp4)?;
+
+    Ok(VideoMetadata {
+      duration,
+      title,
+      tracks,
+    })
   }
 
   pub(crate) fn read(path: &Utf8Path) -> Result<VideoMetadata> {
@@ -255,6 +262,32 @@ impl Mp4Decoder {
 
     Self::metadata(file, size).context(error::Video { path })
   }
+
+  fn title(mp4: &Mp4) -> Result<Option<Text>, VideoError> {
+    let Some(udta) = &mp4.moov.udta else {
+      return Ok(None);
+    };
+
+    let Some(MetaBox::Mdir { ilst: Some(ilst) }) = &udta.meta else {
+      return Ok(None);
+    };
+
+    let Some(item) = ilst.items.get(&MetadataKey::Title) else {
+      return Ok(None);
+    };
+
+    let tag = "©nam";
+
+    let title = str::from_utf8(&item.data.data).context(video_error::TagUtf8 { tag })?;
+
+    ensure!(!title.is_empty(), video_error::TagEmpty { tag });
+
+    Ok(Some(
+      title
+        .parse::<Text>()
+        .context(video_error::TagInvalid { tag })?,
+    ))
+  }
 }
 
 #[cfg(test)]
@@ -322,6 +355,7 @@ mod tests {
       case(Mp4Builder::new().video_track(2, 1).audio_track(0x40)).unwrap(),
       VideoMetadata {
         duration: 0,
+        title: None,
         tracks: vec![
           Track {
             codec: Codec::H264,
@@ -353,6 +387,7 @@ mod tests {
       case(Mp4Builder::new().video_track(2, 1)).unwrap(),
       VideoMetadata {
         duration: 0,
+        title: None,
         tracks: vec![Track {
           codec: Codec::H264,
           info: TrackInfo::Video {
@@ -570,6 +605,28 @@ mod tests {
       "track 1 has unsupported audio codec `unknown`",
     );
 
+    assert_eq!(
+      case(Mp4Builder::new().video_track(2, 1).name("foo"))
+        .unwrap()
+        .title,
+      Some("foo".parse().unwrap()),
+    );
+
+    error(
+      Mp4Builder::new().video_track(2, 1).name(b""),
+      "empty `©nam` tag",
+    );
+
+    error(
+      Mp4Builder::new().video_track(2, 1).name(b"\xff"),
+      "`©nam` tag is not valid UTF-8",
+    );
+
+    error(
+      Mp4Builder::new().video_track(2, 1).name("\0"),
+      "invalid `©nam` tag",
+    );
+
     assert_eq!(
       Mp4Decoder::metadata(io::Cursor::new(b"foo"), 3)
         .unwrap_err()
diff --git a/src/templates/package.rs b/src/templates/package.rs
index 672309ad..73819328 100644
--- a/src/templates/package.rs
+++ b/src/templates/package.rs
@@ -669,7 +669,7 @@ mod tests {
             ],
             ty: VideoType::Mp4,
           },
-          title: None,
+          title: Some("bar".parse().unwrap()),
         }],
       }),
       ..default()
@@ -712,7 +712,7 @@ mod tests {
           </dl>
           <ol>
             <li>
-              <a href=/package/{fingerprint}/item/1>foo.mp4</a>
+              <a href=/package/{fingerprint}/item/1>bar</a>
               <time datetime=PT3M45S>3:45</time>
             </li>
           </ol>
diff --git a/src/templates/video.rs b/src/templates/video.rs
index a93719d8..04fefc43 100644
--- a/src/templates/video.rs
+++ b/src/templates/video.rs
@@ -7,6 +7,16 @@ pub(crate) struct VideoHtml {
   pub(crate) video: usize,
 }
 
+impl VideoHtml {
+  fn video(&self) -> &Item<Video> {
+    let Media::Video { items } = self.metadata.media.as_ref().unwrap() else {
+      unreachable!();
+    };
+
+    &items[self.video]
+  }
+}
+
 impl Page for VideoHtml {
   fn open_graph_image(&self) -> Option<OpenGraphImage> {
     OpenGraphImage::artwork(&self.metadata, self.fingerprint)
@@ -17,7 +27,7 @@ impl Page for VideoHtml {
   }
 
   fn title(&self) -> String {
-    format!("video {} · filepack", self.video)
+    format!("{} · filepack", self.video().display_title())
   }
 }
 
@@ -52,4 +62,23 @@ mod tests {
 
     assert_eq!(html.open_graph_image(), None);
   }
+
+  #[test]
+  fn title() {
+    let html = VideoHtml {
+      fingerprint: test::FINGERPRINT.parse().unwrap(),
+      metadata: Metadata {
+        media: Some(Media::Video {
+          items: vec![Item {
+            content: "foo.mp4".parse().unwrap(),
+            title: Some("bar".parse().unwrap()),
+          }],
+        }),
+        ..default()
+      },
+      video: 0,
+    };
+
+    assert_eq!(Page::title(&html), "bar · filepack");
+  }
 }
diff --git a/src/video.rs b/src/video.rs
index bac46050..53065459 100644
--- a/src/video.rs
+++ b/src/video.rs
@@ -26,10 +26,14 @@ impl Video {
     formats
   }
 
-  pub(crate) fn populate(&mut self, root: &Utf8Path) -> Result {
+  pub(crate) fn populate(&mut self, root: &Utf8Path) -> Result<Option<Text>> {
     let path = root.join(&self.path);
 
-    let VideoMetadata { duration, tracks } = match self.ty {
+    let VideoMetadata {
+      duration,
+      title,
+      tracks,
+    } = match self.ty {
       VideoType::Mp4 => Mp4Decoder::read(&path)?,
       VideoType::Webm => WebmDecoder::read(&path)?,
     };
@@ -37,7 +41,7 @@ impl Video {
     self.duration = duration;
     self.tracks = tracks;
 
-    Ok(())
+    Ok(title)
   }
 
   pub(crate) fn resource_type(&self) -> ResourceType {
@@ -165,7 +169,7 @@ mod tests {
 
       let mut video = "foo.mp4".parse::<Video>().unwrap();
 
-      video.populate(&root).map(|()| video)
+      video.populate(&root).map(|_| video)
     }
 
     assert_eq!(
diff --git a/src/video_error.rs b/src/video_error.rs
index 2dbb7d02..5403e052 100644
--- a/src/video_error.rs
+++ b/src/video_error.rs
@@ -31,6 +31,22 @@ pub enum VideoError {
   SpsInvalid,
   #[snafu(display("missing SPS"))]
   SpsMissing,
+  #[snafu(display("binary `{tag}` tag"))]
+  TagBinary { tag: &'static str },
+  #[snafu(display("empty `{tag}` tag"))]
+  TagEmpty { tag: &'static str },
+  #[snafu(display("invalid `{tag}` tag"))]
+  TagInvalid {
+    source: TextError,
+    tag: &'static str,
+  },
+  #[snafu(display("multiple `{tag}` tags"))]
+  TagMultiple { tag: &'static str },
+  #[snafu(display("`{tag}` tag is not valid UTF-8"))]
+  TagUtf8 {
+    source: Utf8Error,
+    tag: &'static str,
+  },
   #[snafu(display("zero timescale"))]
   TimescaleZero,
   #[snafu(display("unsupported timestamp scale {timestamp_scale}"))]
diff --git a/src/video_metadata.rs b/src/video_metadata.rs
index 57fcc1ea..4fb76ff4 100644
--- a/src/video_metadata.rs
+++ b/src/video_metadata.rs
@@ -3,5 +3,6 @@ use super::*;
 #[derive(Debug, PartialEq)]
 pub(crate) struct VideoMetadata {
   pub(crate) duration: u64,
+  pub(crate) title: Option<Text>,
   pub(crate) tracks: Vec<Track>,
 }
diff --git a/src/webm_builder.rs b/src/webm_builder.rs
index fb966aa4..2a3a3ddc 100644
--- a/src/webm_builder.rs
+++ b/src/webm_builder.rs
@@ -2,6 +2,8 @@ pub(crate) struct WebmBuilder {
   blocks: Vec<Vec<u8>>,
   doc_type: String,
   duration: Option<f64>,
+  tags: Vec<Vec<u8>>,
+  target_type_value: u64,
   timestamp_scale: Option<u64>,
   tracks: Vec<Vec<u8>>,
 }
@@ -24,6 +26,19 @@ impl WebmBuilder {
     self.track(2, codec_id, &settings)
   }
 
+  #[must_use]
+  pub(crate) fn binary_tag(mut self, name: &str, value: &[u8]) -> Self {
+    self.tags.push(Self::element(
+      &[0x67, 0xC8],
+      &[
+        Self::string(&[0x45, 0xA3], name),
+        Self::element(&[0x44, 0x85], value),
+      ]
+      .concat(),
+    ));
+    self
+  }
+
   pub(crate) fn build(self) -> Vec<u8> {
     let header = [
       Self::string(&[0x42, 0x82], &self.doc_type),
@@ -46,9 +61,29 @@ impl WebmBuilder {
     ]
     .concat();
 
+    let tags = if self.tags.is_empty() {
+      Vec::new()
+    } else {
+      Self::element(
+        &[0x12, 0x54, 0xC3, 0x67],
+        &Self::element(
+          &[0x73, 0x73],
+          &[
+            Self::element(
+              &[0x63, 0xC0],
+              &Self::unsigned(&[0x68, 0xCA], self.target_type_value),
+            ),
+            self.tags.concat(),
+          ]
+          .concat(),
+        ),
+      )
+    };
+
     let segment = [
       Self::element(&[0x15, 0x49, 0xA9, 0x66], &info),
       Self::element(&[0x16, 0x54, 0xAE, 0x6B], &self.tracks.concat()),
+      tags,
       Self::element(&[0x1F, 0x43, 0xB6, 0x75], &self.blocks.concat()),
     ]
     .concat();
@@ -101,6 +136,8 @@ impl WebmBuilder {
       blocks: Vec::new(),
       doc_type: "webm".into(),
       duration: Some(0.0),
+      tags: Vec::new(),
+      target_type_value: 50,
       timestamp_scale: None,
       tracks: Vec::new(),
     }
@@ -116,12 +153,31 @@ impl WebmBuilder {
     Self::element(id, value.as_bytes())
   }
 
+  #[must_use]
+  pub(crate) fn target_type_value(mut self, target_type_value: u64) -> Self {
+    self.target_type_value = target_type_value;
+    self
+  }
+
   #[must_use]
   pub(crate) fn timestamp_scale(mut self, timestamp_scale: u64) -> Self {
     self.timestamp_scale = Some(timestamp_scale);
     self
   }
 
+  #[must_use]
+  pub(crate) fn title(mut self, title: &str) -> Self {
+    self.tags.push(Self::element(
+      &[0x67, 0xC8],
+      &[
+        Self::string(&[0x45, 0xA3], "TITLE"),
+        Self::string(&[0x44, 0x87], title),
+      ]
+      .concat(),
+    ));
+    self
+  }
+
   #[must_use]
   pub(crate) fn track(mut self, ty: u64, codec_id: &str, settings: &[u8]) -> Self {
     let number = u64::try_from(self.tracks.len() + 1).unwrap();
diff --git a/src/webm_decoder.rs b/src/webm_decoder.rs
index 0e9ecded..251b7212 100644
--- a/src/webm_decoder.rs
+++ b/src/webm_decoder.rs
@@ -1,11 +1,12 @@
-use super::*;
+use {
+  super::*,
+  matroska_demuxer::{Frame, MatroskaFile, TrackType},
+};
 
 pub(crate) struct WebmDecoder;
 
 impl WebmDecoder {
   fn metadata<T: Read + Seek>(reader: T) -> Result<VideoMetadata, VideoError> {
-    use matroska_demuxer::{Frame, MatroskaFile, TrackType};
-
     let mut file = MatroskaFile::open(BufReader::new(reader)).context(video_error::DecodeWebm)?;
 
     let doc_type = file.ebml_header().doc_type().trim_end_matches('\0');
@@ -178,7 +179,13 @@ impl WebmDecoder {
       tracks.push(audio_track);
     }
 
-    Ok(VideoMetadata { duration, tracks })
+    let title = Self::title(&file)?;
+
+    Ok(VideoMetadata {
+      duration,
+      title,
+      tracks,
+    })
   }
 
   pub(crate) fn read(path: &Utf8Path) -> Result<VideoMetadata> {
@@ -187,6 +194,45 @@ impl WebmDecoder {
     Self::metadata(file).context(error::Video { path })
   }
 
+  fn title<T: Read + Seek>(file: &MatroskaFile<T>) -> Result<Option<Text>, VideoError> {
+    let tag = "TITLE";
+
+    let mut title = None;
+
+    for entry in file.tags().unwrap_or_default() {
+      if let Some(targets) = entry.targets()
+        && (!matches!(targets.target_type_value(), None | Some(50))
+          || !matches!(targets.tag_track_uid(), None | Some(0)))
+      {
+        continue;
+      }
+
+      for simple_tag in entry.simple_tags() {
+        if simple_tag.name() == tag {
+          ensure! {
+            title.is_none(),
+            video_error::TagMultiple { tag },
+          }
+          title = Some(simple_tag);
+        }
+      }
+    }
+
+    let Some(title) = title else {
+      return Ok(None);
+    };
+
+    let title = title.string().context(video_error::TagBinary { tag })?;
+
+    ensure!(!title.is_empty(), video_error::TagEmpty { tag });
+
+    Ok(Some(
+      title
+        .parse::<Text>()
+        .context(video_error::TagInvalid { tag })?,
+    ))
+  }
+
   fn vp9_color_info(data: &[u8]) -> Option<ColorInfo> {
     let mut reader = BitReader::new(data);
 
@@ -305,6 +351,7 @@ mod tests {
       .unwrap(),
       VideoMetadata {
         duration: 0,
+        title: None,
         tracks: vec![
           Track {
             codec: Codec::Vp9,
@@ -341,6 +388,7 @@ mod tests {
       .unwrap(),
       VideoMetadata {
         duration: 0,
+        title: None,
         tracks: vec![
           Track {
             codec: Codec::Vp8,
@@ -372,6 +420,7 @@ mod tests {
       case(WebmBuilder::new().video_track(2, 1).frame(1, VP9_FRAME)).unwrap(),
       VideoMetadata {
         duration: 0,
+        title: None,
         tracks: vec![Track {
           codec: Codec::Vp9,
           info: TrackInfo::Video {
@@ -585,6 +634,64 @@ mod tests {
       "expected DocType `webm` but found `matroska`",
     );
 
+    assert_eq!(
+      case(
+        WebmBuilder::new()
+          .video_track(2, 1)
+          .frame(1, VP9_FRAME)
+          .title("foo"),
+      )
+      .unwrap()
+      .title,
+      Some("foo".parse().unwrap()),
+    );
+
+    assert_eq!(
+      case(
+        WebmBuilder::new()
+          .video_track(2, 1)
+          .frame(1, VP9_FRAME)
+          .title("foo")
+          .target_type_value(30),
+      )
+      .unwrap()
+      .title,
+      None,
+    );
+
+    error(
+      WebmBuilder::new()
+        .video_track(2, 1)
+        .frame(1, VP9_FRAME)
+        .title(""),
+      "empty `TITLE` tag",
+    );
+
+    error(
+      WebmBuilder::new()
+        .video_track(2, 1)
+        .frame(1, VP9_FRAME)
+        .title("\0"),
+      "invalid `TITLE` tag",
+    );
+
+    error(
+      WebmBuilder::new()
+        .video_track(2, 1)
+        .frame(1, VP9_FRAME)
+        .binary_tag("TITLE", b"foo"),
+      "binary `TITLE` tag",
+    );
+
+    error(
+      WebmBuilder::new()
+        .video_track(2, 1)
+        .frame(1, VP9_FRAME)
+        .title("foo")
+        .title("bar"),
+      "multiple `TITLE` tags",
+    );
+
     assert_eq!(
       WebmDecoder::metadata(io::Cursor::new(b"foo"))
         .unwrap_err()
diff --git a/templates/package.html b/templates/package.html
index c30dbc27..2396c97b 100644
--- a/templates/package.html
+++ b/templates/package.html
@@ -163,7 +163,7 @@ <h2>disc {{ disc[0].content.disc }}</h2>
 %%       for (i, video) in items.iter().enumerate() {
 %%         let duration = Duration::from_millis(video.content.duration);
   <li>
-    <a href=/package/{{ self.fingerprint }}/item/{{ Ordinal(i) }}>{{ video.content.path }}</a>
+    <a href=/package/{{ self.fingerprint }}/item/{{ Ordinal(i) }}>{{ video.display_title() }}</a>
     <time datetime={{ Iso8601Duration(duration) }}>{{ DisplayDuration(duration) }}</time>
   </li>
 %%       }
diff --git a/tests/metadata.rs b/tests/metadata.rs
index 913ab459..cd1d28a4 100644
--- a/tests/metadata.rs
+++ b/tests/metadata.rs
@@ -233,6 +233,7 @@ fn create_extracts_video_metadata() {
         .frame_count(30)
         .video_track(2, 1)
         .audio_track(0x40)
+        .name("bar")
         .build(),
     )
     .write(
@@ -287,7 +288,8 @@ fn create_extracts_video_metadata() {
                     }
                   ],
                   "type": "mp4"
-                }
+                },
+                "title": "bar"
               }
             ]
           }

From 212ecaea72927db7dde817d60be3d7d6b0e03b88 Mon Sep 17 00:00:00 2001
From: Casey Rodarmor <casey@rodarmor.com>
Date: Mon, 24 Aug 2026 20:54:46 -0700
Subject: [PATCH 2/2] Read correct WebM tag

---
 src/video_error.rs  |  4 ---
 src/webm_builder.rs | 59 ++++++----------------------------------
 src/webm_decoder.rs | 65 +++++----------------------------------------
 3 files changed, 14 insertions(+), 114 deletions(-)

diff --git a/src/video_error.rs b/src/video_error.rs
index 5403e052..53327f7d 100644
--- a/src/video_error.rs
+++ b/src/video_error.rs
@@ -31,8 +31,6 @@ pub enum VideoError {
   SpsInvalid,
   #[snafu(display("missing SPS"))]
   SpsMissing,
-  #[snafu(display("binary `{tag}` tag"))]
-  TagBinary { tag: &'static str },
   #[snafu(display("empty `{tag}` tag"))]
   TagEmpty { tag: &'static str },
   #[snafu(display("invalid `{tag}` tag"))]
@@ -40,8 +38,6 @@ pub enum VideoError {
     source: TextError,
     tag: &'static str,
   },
-  #[snafu(display("multiple `{tag}` tags"))]
-  TagMultiple { tag: &'static str },
   #[snafu(display("`{tag}` tag is not valid UTF-8"))]
   TagUtf8 {
     source: Utf8Error,
diff --git a/src/webm_builder.rs b/src/webm_builder.rs
index 2a3a3ddc..f951c4cd 100644
--- a/src/webm_builder.rs
+++ b/src/webm_builder.rs
@@ -2,9 +2,8 @@ pub(crate) struct WebmBuilder {
   blocks: Vec<Vec<u8>>,
   doc_type: String,
   duration: Option<f64>,
-  tags: Vec<Vec<u8>>,
-  target_type_value: u64,
   timestamp_scale: Option<u64>,
+  title: Option<String>,
   tracks: Vec<Vec<u8>>,
 }
 
@@ -26,19 +25,6 @@ impl WebmBuilder {
     self.track(2, codec_id, &settings)
   }
 
-  #[must_use]
-  pub(crate) fn binary_tag(mut self, name: &str, value: &[u8]) -> Self {
-    self.tags.push(Self::element(
-      &[0x67, 0xC8],
-      &[
-        Self::string(&[0x45, 0xA3], name),
-        Self::element(&[0x44, 0x85], value),
-      ]
-      .concat(),
-    ));
-    self
-  }
-
   pub(crate) fn build(self) -> Vec<u8> {
     let header = [
       Self::string(&[0x42, 0x82], &self.doc_type),
@@ -56,34 +42,19 @@ impl WebmBuilder {
         .duration
         .map(|duration| Self::float(&[0x44, 0x89], duration))
         .unwrap_or_default(),
+      self
+        .title
+        .as_deref()
+        .map(|title| Self::string(&[0x7B, 0xA9], title))
+        .unwrap_or_default(),
       Self::string(&[0x4D, 0x80], "foo"),
       Self::string(&[0x57, 0x41], "bar"),
     ]
     .concat();
 
-    let tags = if self.tags.is_empty() {
-      Vec::new()
-    } else {
-      Self::element(
-        &[0x12, 0x54, 0xC3, 0x67],
-        &Self::element(
-          &[0x73, 0x73],
-          &[
-            Self::element(
-              &[0x63, 0xC0],
-              &Self::unsigned(&[0x68, 0xCA], self.target_type_value),
-            ),
-            self.tags.concat(),
-          ]
-          .concat(),
-        ),
-      )
-    };
-
     let segment = [
       Self::element(&[0x15, 0x49, 0xA9, 0x66], &info),
       Self::element(&[0x16, 0x54, 0xAE, 0x6B], &self.tracks.concat()),
-      tags,
       Self::element(&[0x1F, 0x43, 0xB6, 0x75], &self.blocks.concat()),
     ]
     .concat();
@@ -136,9 +107,8 @@ impl WebmBuilder {
       blocks: Vec::new(),
       doc_type: "webm".into(),
       duration: Some(0.0),
-      tags: Vec::new(),
-      target_type_value: 50,
       timestamp_scale: None,
+      title: None,
       tracks: Vec::new(),
     }
   }
@@ -153,12 +123,6 @@ impl WebmBuilder {
     Self::element(id, value.as_bytes())
   }
 
-  #[must_use]
-  pub(crate) fn target_type_value(mut self, target_type_value: u64) -> Self {
-    self.target_type_value = target_type_value;
-    self
-  }
-
   #[must_use]
   pub(crate) fn timestamp_scale(mut self, timestamp_scale: u64) -> Self {
     self.timestamp_scale = Some(timestamp_scale);
@@ -167,14 +131,7 @@ impl WebmBuilder {
 
   #[must_use]
   pub(crate) fn title(mut self, title: &str) -> Self {
-    self.tags.push(Self::element(
-      &[0x67, 0xC8],
-      &[
-        Self::string(&[0x45, 0xA3], "TITLE"),
-        Self::string(&[0x44, 0x87], title),
-      ]
-      .concat(),
-    ));
+    self.title = Some(title.into());
     self
   }
 
diff --git a/src/webm_decoder.rs b/src/webm_decoder.rs
index 251b7212..c2f396a5 100644
--- a/src/webm_decoder.rs
+++ b/src/webm_decoder.rs
@@ -179,7 +179,7 @@ impl WebmDecoder {
       tracks.push(audio_track);
     }
 
-    let title = Self::title(&file)?;
+    let title = Self::title(file.info())?;
 
     Ok(VideoMetadata {
       duration,
@@ -194,36 +194,13 @@ impl WebmDecoder {
     Self::metadata(file).context(error::Video { path })
   }
 
-  fn title<T: Read + Seek>(file: &MatroskaFile<T>) -> Result<Option<Text>, VideoError> {
-    let tag = "TITLE";
+  fn title(info: &matroska_demuxer::Info) -> Result<Option<Text>, VideoError> {
+    let tag = "Title";
 
-    let mut title = None;
-
-    for entry in file.tags().unwrap_or_default() {
-      if let Some(targets) = entry.targets()
-        && (!matches!(targets.target_type_value(), None | Some(50))
-          || !matches!(targets.tag_track_uid(), None | Some(0)))
-      {
-        continue;
-      }
-
-      for simple_tag in entry.simple_tags() {
-        if simple_tag.name() == tag {
-          ensure! {
-            title.is_none(),
-            video_error::TagMultiple { tag },
-          }
-          title = Some(simple_tag);
-        }
-      }
-    }
-
-    let Some(title) = title else {
+    let Some(title) = info.title() else {
       return Ok(None);
     };
 
-    let title = title.string().context(video_error::TagBinary { tag })?;
-
     ensure!(!title.is_empty(), video_error::TagEmpty { tag });
 
     Ok(Some(
@@ -646,25 +623,12 @@ mod tests {
       Some("foo".parse().unwrap()),
     );
 
-    assert_eq!(
-      case(
-        WebmBuilder::new()
-          .video_track(2, 1)
-          .frame(1, VP9_FRAME)
-          .title("foo")
-          .target_type_value(30),
-      )
-      .unwrap()
-      .title,
-      None,
-    );
-
     error(
       WebmBuilder::new()
         .video_track(2, 1)
         .frame(1, VP9_FRAME)
         .title(""),
-      "empty `TITLE` tag",
+      "empty `Title` tag",
     );
 
     error(
@@ -672,24 +636,7 @@ mod tests {
         .video_track(2, 1)
         .frame(1, VP9_FRAME)
         .title("\0"),
-      "invalid `TITLE` tag",
-    );
-
-    error(
-      WebmBuilder::new()
-        .video_track(2, 1)
-        .frame(1, VP9_FRAME)
-        .binary_tag("TITLE", b"foo"),
-      "binary `TITLE` tag",
-    );
-
-    error(
-      WebmBuilder::new()
-        .video_track(2, 1)
-        .frame(1, VP9_FRAME)
-        .title("foo")
-        .title("bar"),
-      "multiple `TITLE` tags",
+      "invalid `Title` tag",
     );
 
     assert_eq!(