AK+LibMedia+LibWeb+Tests: Implement buffered ranges for various formats

AK/RedBlackTree.h

@@ -559,6 +559,25 @@ class RedBlackTree final : public BaseRedBlackTree<K> {
         return temp;
     }
 
+    V remove_and_advance(Iterator& iterator)
+    {
+        VERIFY(!iterator.is_end());
+
+        auto* node = iterator.m_node;
+        auto* successor = static_cast<Node*>(BaseTree::successor(node));
+        iterator.m_node = successor;
+
+        BaseTree::remove(node);
+
+        V temp = move(node->value);
+
+        node->right_child = nullptr;
+        node->left_child = nullptr;
+        delete node;
+
+        return temp;
+    }
+
     bool remove(K key)
     {
         auto* node = BaseTree::find(this->m_root, key);

Libraries/LibMedia/CMakeLists.txt

@@ -2,8 +2,18 @@ include(audio)
 
 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
+    Containers/Matroska/Streamer.cpp
     GenericTimeProvider.cpp
     IncrementallyPopulatedStream.cpp
     PlaybackManager.cpp

Libraries/LibMedia/Codecs/FLAC.cpp

@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2026-present, the Ladybird developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/BuiltinWrappers.h>
+#include <LibMedia/Codecs/FLAC.h>
+#include <LibMedia/MediaStream.h>
+
+namespace Media::Codecs {
+
+template<Integral T>
+static Optional<T> read_big_endian_value(MediaStreamCursor& cursor)
+{
+    auto value = cursor.read_value<T>(AK::Endianness::Big);
+    if (value.is_error())
+        return {};
+    return value.release_value();
+}
+
+static Optional<u64> read_coded_number(MediaStreamCursor& cursor)
+{
+    auto first_byte = read_big_endian_value<u8>(cursor);
+    if (!first_byte.has_value())
+        return {};
+    u64 value = first_byte.value();
+
+    auto length = count_leading_zeroes_safe(static_cast<u8>(~value));
+    if (length == 0)
+        return value;
+    if (length == 1)
+        return {};
+    if (length > 7)
+        return {};
+
+    value &= (1 << (8 - (length + 1))) - 1;
+    while (--length > 0) {
+        auto continuation_byte = read_big_endian_value<u8>(cursor);
+        if (!continuation_byte.has_value())
+            return {};
+        if (continuation_byte.value() >> 6 != 0b10)
+            return {};
+        value <<= 6;
+        value |= continuation_byte.value() & 0b111111;
+    }
+
+    return value;
+}
+
+static bool verify_header_crc(MediaStreamCursor& cursor, size_t header_start)
+{
+    constexpr auto lookup_table = [] {
+        Array<u8, 256> result;
+        for (size_t i = 0; i < result.size(); i++) {
+            u8 value = i;
+            for (auto j = 0; j < 8; j++)
+                value = (value << 1) ^ (value & 0x80 ? 0x07 : 0);
+            result[i] = value;
+        }
+        return result;
+    }();
+
+    auto header_end = cursor.position();
+    VERIFY(header_end > header_start);
+    auto header_size = header_end - header_start;
+    Array<u8, 16> buffer;
+    if (header_size > buffer.size())
+        return false;
+
+    auto crc = read_big_endian_value<u8>(cursor);
+    if (!crc.has_value())
+        return false;
+
+    if (cursor.seek_to_position(header_start).is_error())
+        return false;
+    auto header_data = buffer.span().trim(header_size);
+    if (cursor.read_until_filled(header_data).is_error())
+        return false;
+    if (cursor.skip(1).is_error())
+        return false;
+
+    u8 actual_crc = 0;
+    for (auto const& byte : header_data)
+        actual_crc = lookup_table[actual_crc ^ byte];
+    return crc.value() == actual_crc;
+}
+
+bool FLAC::is_sync_code(u16 value)
+{
+    return (value >> 1) == 0b111111111111100;
+}
+
+Optional<FLAC::FrameInfo> FLAC::parse_frame_header(MediaStreamCursor& cursor, u16 sync_code, u16 fixed_block_size)
+{
+    auto header_start = cursor.position();
+
+    Array<u8, 4> header;
+    if (cursor.read_until_filled(header).is_error())
+        return {};
+
+    u16 maybe_sync_code = (static_cast<u16>(header[0]) << 8) | header[1];
+    if (maybe_sync_code != sync_code)
+        return {};
+
+    bool variable_block_size = (sync_code & 1) != 0;
+    u8 block_size_bits = (header[2] >> 4) & 0x0F;
+    u8 sample_rate_bits = header[2] & 0x0F;
+    u8 channels_bits = (header[3] >> 4) & 0x0F;
+    u8 bit_depth_bits = (header[3] >> 1) & 0x07;
+    u8 reserved_bit = header[3] & 0x01;
+
+    if (reserved_bit != 0)
+        return {};
+
+    auto coded_number = read_coded_number(cursor);
+    if (!coded_number.has_value())
+        return {};
+
+    u16 block_size = 0;
+    if (block_size_bits == 0b0000)
+        return {};
+    if (block_size_bits == 0b0001) {
+        block_size = 192;
+    } else if (block_size_bits <= 0b0101) {
+        block_size = 144 * (1 << block_size_bits);
+    } else if (block_size_bits == 0b0110) {
+        auto uncommon_block_size_minus_1 = read_big_endian_value<u8>(cursor);
+        if (!uncommon_block_size_minus_1.has_value())
+            return {};
+        block_size = uncommon_block_size_minus_1.value() + 1;
+    } else if (block_size_bits == 0b0111) {
+        auto uncommon_block_size_minus_1 = read_big_endian_value<u16>(cursor);
+        if (!uncommon_block_size_minus_1.has_value())
+            return {};
+        block_size = uncommon_block_size_minus_1.value() + 1;
+    } else if (block_size_bits >= 0b1000) {
+        block_size = 1 << block_size_bits;
+    }
+
+    if (sample_rate_bits == 0b1100 && cursor.skip(1).is_error())
+        return {};
+    if ((sample_rate_bits == 0b1101 || sample_rate_bits == 0b1110) && cursor.skip(2).is_error())
+        return {};
+    if (sample_rate_bits == 0b1111)
+        return {};
+
+    if (channels_bits >= 0b1011)
+        return {};
+
+    if (bit_depth_bits == 0b011)
+        return {};
+
+    if (!verify_header_crc(cursor, header_start))
+        return {};
+
+    u64 sample_number = coded_number.value();
+    if (!variable_block_size)
+        sample_number *= fixed_block_size;
+
+    return FrameInfo { sample_number, block_size };
+}
+
+}

Libraries/LibMedia/Codecs/FLAC.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026-present, the Ladybird developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Optional.h>
+#include <LibMedia/Forward.h>
+
+namespace Media::Codecs {
+
+class FLAC {
+public:
+    struct FrameInfo {
+        u64 sample_number;
+        u16 block_size;
+    };
+
+    static bool is_sync_code(u16);
+    static Optional<FrameInfo> parse_frame_header(MediaStreamCursor&, u16 sync_code, u16 fixed_block_size);
+};
+
+}

Libraries/LibMedia/Codecs/Opus.cpp

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026-present, the Ladybird developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibMedia/Codecs/Opus.h>
+#include <LibMedia/MediaStream.h>
+
+namespace Media::Codecs {
+
+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);
+
+    // https://datatracker.ietf.org/doc/html/rfc6716#section-3.1
+    auto toc_byte = TRY(cursor.read_value<u8>());
+    auto configuration_number = (toc_byte >> 3) & 0b1'1111;
+    auto packet_code = toc_byte & 0b11;
+
+    // clang-format off
+    constexpr Array frame_durations = {
+            10000, 20000, 40000, 60000, // SILK-only NB
+            10000, 20000, 40000, 60000, // SILK-only MB
+            10000, 20000, 40000, 60000, // SILK-only WB
+            10000, 20000,               // Hybrid SWB
+            10000, 20000,               // Hybrid FB
+            2500,  5000,  10000, 20000, // CELT-only NB
+            2500,  5000,  10000, 20000, // CELT-only WB
+            2500,  5000,  10000, 20000, // CELT-only SWB
+            2500,  5000,  10000, 20000, // CELT-only FB
+    };
+    // clang-format on
+
+    auto frame_duration = frame_durations[configuration_number];
+    auto packet_duration = TRY([&] -> DecoderErrorOr<int> {
+        switch (packet_code) {
+        case 0:
+            return frame_duration;
+        case 1:
+        case 2:
+            return frame_duration * 2;
+        case 3: {
+            if (frame_size == 1)
+                return DecoderError::corrupted("Opus frame is too small"sv);
+            auto frame_count_byte = TRY(cursor.read_value<u8>());
+            auto frame_count = frame_count_byte & 0b11'1111;
+            return frame_duration * frame_count;
+        }
+        default:
+            VERIFY_NOT_REACHED();
+        }
+    }());
+
+    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

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2026-present, the Ladybird developers.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Time.h>
+#include <LibMedia/DecoderError.h>
+#include <LibMedia/Forward.h>
+
+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);
+};
+
+}