LibMedia: Implement buffered range scanning for Ogg

Unfortunately, this necessarily involves parsing codec frames to get
their durations. Ogg's granule positions indicate the last sample of
the last complete frame of the page, so the navigator has to determine
the durations of every packet in the page to offset it back to its
start.

Vorbis is an especially involved codec to determine that for, since it
has initial data defining a mapping of indices to big or small block
sizes that has to be held onto, and that mapping is preceded by a bunch
of conditionally parsed bits. Also, a frame's block size calculation
involves the block size of the previous frame for an overlap add. To
avoid bringing that complexity directly into LibMedia, we delegate the
parsing/calculation to FFmpeg's av_vorbis_parse functions.

Author: Zaggy1024

Libraries/LibMedia/CMakeLists.txt

@@ -4,10 +4,12 @@ set(SOURCES
     Audio/AudioDevices.cpp
     Codecs/FLAC.cpp
     Codecs/Opus.cpp
+    Codecs/Vorbis.cpp
     Containers/ConstantBitrateContainerNavigator.cpp
     Containers/FLACNavigator.cpp
     Containers/IndexedContainerNavigator.cpp
     Containers/MP3Navigator.cpp
+    Containers/OggNavigator.cpp
     Containers/Matroska/MatroskaDemuxer.cpp
     Containers/Matroska/Reader.cpp
     Containers/Matroska/SampleIterator.cpp

Libraries/LibMedia/Codecs/Opus.cpp

@@ -9,7 +9,7 @@
 
 namespace Media::Codecs {
 
-DecoderErrorOr<AK::Duration> Opus::parse_frame_duration(MediaStreamCursor& cursor, size_t frame_size)
+DecoderErrorOr<u32> Opus::parse_frame_duration_in_samples(MediaStreamCursor& cursor, size_t frame_size)
 {
     if (frame_size == 0)
         return DecoderError::corrupted("Opus frame is too small"sv);
@@ -53,7 +53,12 @@ DecoderErrorOr<AK::Duration> Opus::parse_frame_duration(MediaStreamCursor& curso
         }
     }());
 
-    return AK::Duration::from_microseconds(packet_duration);
+    return packet_duration * 48 / 1000;
+}
+
+DecoderErrorOr<AK::Duration> Opus::parse_frame_duration(MediaStreamCursor& cursor, size_t frame_size)
+{
+    return AK::Duration::from_time_units(TRY(parse_frame_duration_in_samples(cursor, frame_size)), 1, 48000);
 }
 
 }

Libraries/LibMedia/Codecs/Opus.h

@@ -15,6 +15,7 @@ namespace Media::Codecs {
 class Opus {
 public:
     static DecoderErrorOr<AK::Duration> parse_frame_duration(MediaStreamCursor&, size_t frame_size);
+    static DecoderErrorOr<u32> parse_frame_duration_in_samples(MediaStreamCursor&, size_t frame_size);
 };
 
 }

Libraries/LibMedia/Codecs/Vorbis.cpp

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026-present, the Ladybird developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/Math.h>
+#include <LibMedia/Codecs/Vorbis.h>
+
+extern "C" {
+#include <libavcodec/vorbis_parser.h>
+}
+
+namespace Media::Codecs {
+
+Optional<Vorbis::Parser> Vorbis::Parser::create(ReadonlyBytes codec_initialization_data)
+{
+    if (codec_initialization_data.is_empty())
+        return {};
+
+    auto* parser = av_vorbis_parse_init(codec_initialization_data.data(), AK::clamp_to<int>(codec_initialization_data.size()));
+    if (!parser)
+        return {};
+    return Parser { parser };
+}
+
+Vorbis::Parser::Parser(AVVorbisParseContext* context)
+    : m_context(context)
+{
+    VERIFY(m_context);
+}
+
+Vorbis::Parser::Parser(Parser&& other)
+    : m_context(exchange(other.m_context, nullptr))
+{
+}
+
+Vorbis::Parser& Vorbis::Parser::operator=(Parser&& other)
+{
+    if (this == &other)
+        return *this;
+
+    if (m_context)
+        av_vorbis_parse_free(&m_context);
+    m_context = exchange(other.m_context, nullptr);
+    return *this;
+}
+
+Vorbis::Parser::~Parser()
+{
+    if (m_context)
+        av_vorbis_parse_free(&m_context);
+}
+
+void Vorbis::Parser::reset() const
+{
+    av_vorbis_parse_reset(m_context);
+}
+
+Optional<u32> Vorbis::Parser::parse_packet_duration_in_samples(ReadonlyBytes packet) const
+{
+    int flags = 0;
+    auto duration = av_vorbis_parse_frame_flags(m_context, packet.data(), AK::clamp_to<int>(packet.size()), &flags);
+    if (duration < 0)
+        return {};
+    return duration;
+}
+
+Optional<AK::Duration> Vorbis::Parser::parse_packet_duration(ReadonlyBytes packet, u32 sample_rate) const
+{
+    auto duration = parse_packet_duration_in_samples(packet);
+    if (!duration.has_value())
+        return {};
+    return AK::Duration::from_time_units(duration.value(), 1, sample_rate);
+}
+
+}

Libraries/LibMedia/Codecs/Vorbis.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2026-present, the Ladybird developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Noncopyable.h>
+#include <AK/Optional.h>
+#include <AK/Span.h>
+#include <AK/Time.h>
+
+struct AVVorbisParseContext;
+
+namespace Media::Codecs {
+
+class Vorbis {
+public:
+    class Parser {
+        AK_MAKE_NONCOPYABLE(Parser);
+
+    public:
+        static Optional<Parser> create(ReadonlyBytes codec_initialization_data);
+
+        Parser(Parser&&);
+        Parser& operator=(Parser&&);
+        ~Parser();
+
+        void reset() const;
+        Optional<u32> parse_packet_duration_in_samples(ReadonlyBytes packet) const;
+        Optional<AK::Duration> parse_packet_duration(ReadonlyBytes packet, u32 sample_rate) const;
+
+    private:
+        explicit Parser(AVVorbisParseContext*);
+
+        AVVorbisParseContext* m_context { nullptr };
+    };
+};
+
+}