LibVideo: Reorganize demuxer file hierarchy and rename Matroska files

As new demuxers are added, this will get quite full of files, so it'll
be good to have a separate folder for these.

To avoid too many chained namespaces, the Containers subdirectory is
not also a namespace, but the Matroska folder is for the sake of
separating the multiple classes for parsed information entering the
Video namespace.

Userland/Libraries/LibVideo/Containers/Matroska/Document.h

@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2021, Hunter Salyer <thefalsehonesty@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/ByteBuffer.h>
+#include <AK/FlyString.h>
+#include <AK/HashMap.h>
+#include <AK/NonnullOwnPtrVector.h>
+#include <AK/OwnPtr.h>
+#include <AK/String.h>
+#include <AK/Utf8View.h>
+#include <LibVideo/Color/CodingIndependentCodePoints.h>
+
+namespace Video::Matroska {
+
+struct EBMLHeader {
+    String doc_type;
+    u32 doc_type_version;
+};
+
+class SegmentInformation {
+public:
+    u64 timestamp_scale() const { return m_timestamp_scale; }
+    void set_timestamp_scale(u64 timestamp_scale) { m_timestamp_scale = timestamp_scale; }
+    Utf8View muxing_app() const { return Utf8View(m_muxing_app); }
+    void set_muxing_app(String muxing_app) { m_muxing_app = move(muxing_app); }
+    Utf8View writing_app() const { return Utf8View(m_writing_app); }
+    void set_writing_app(String writing_app) { m_writing_app = move(writing_app); }
+    Optional<double> duration() const { return m_duration; }
+    void set_duration(double duration) { m_duration.emplace(duration); }
+
+private:
+    u64 m_timestamp_scale { 1'000'000 };
+    String m_muxing_app;
+    String m_writing_app;
+    Optional<double> m_duration;
+};
+
+class TrackEntry {
+public:
+    enum TrackType : u8 {
+        Invalid = 0,
+        Video = 1,
+        Audio = 2,
+        Complex = 3,
+        Logo = 16,
+        Subtitle = 17,
+        Buttons = 18,
+        Control = 32,
+        Metadata = 33,
+    };
+
+    enum class ColorRange : u8 {
+        Unspecified = 0,
+        Broadcast = 1,
+        Full = 2,
+        UseCICP = 3, // defined by MatrixCoefficients / TransferCharacteristics
+    };
+
+    struct ColorFormat {
+        ColorPrimaries color_primaries = ColorPrimaries::Unspecified;
+        TransferCharacteristics transfer_characteristics = TransferCharacteristics::Unspecified;
+        MatrixCoefficients matrix_coefficients = MatrixCoefficients::Unspecified;
+        u64 bits_per_channel = 0;
+        ColorRange range = ColorRange::Unspecified;
+
+        CodingIndependentCodePoints to_cicp() const
+        {
+            Video::ColorRange color_range;
+            switch (range) {
+            case ColorRange::Full:
+                color_range = Video::ColorRange::Full;
+                break;
+            case ColorRange::Broadcast:
+                color_range = Video::ColorRange::Studio;
+                break;
+            case ColorRange::Unspecified:
+            case ColorRange::UseCICP:
+                // FIXME: Figure out what UseCICP should do here. Matroska specification did not
+                //        seem to explain in the 'colour' section. When this is fixed, change
+                //        replace_code_points_if_specified to match.
+                color_range = Video::ColorRange::Unspecified;
+                break;
+            }
+
+            return { color_primaries, transfer_characteristics, matrix_coefficients, color_range };
+        }
+    };
+
+    struct VideoTrack {
+        u64 pixel_width;
+        u64 pixel_height;
+
+        ColorFormat color_format;
+    };
+
+    struct AudioTrack {
+        u64 channels;
+        u64 bit_depth;
+    };
+
+    u64 track_number() const { return m_track_number; }
+    void set_track_number(u64 track_number) { m_track_number = track_number; }
+    u64 track_uid() const { return m_track_uid; }
+    void set_track_uid(u64 track_uid) { m_track_uid = track_uid; }
+    TrackType track_type() const { return m_track_type; }
+    void set_track_type(TrackType track_type) { m_track_type = track_type; }
+    FlyString language() const { return m_language; }
+    void set_language(FlyString const& language) { m_language = language; }
+    FlyString codec_id() const { return m_codec_id; }
+    void set_codec_id(FlyString const& codec_id) { m_codec_id = codec_id; }
+    Optional<VideoTrack> video_track() const
+    {
+        if (track_type() != Video)
+            return {};
+        return m_video_track;
+    }
+    void set_video_track(VideoTrack video_track) { m_video_track = video_track; }
+    Optional<AudioTrack> audio_track() const
+    {
+        if (track_type() != Audio)
+            return {};
+        return m_audio_track;
+    }
+    void set_audio_track(AudioTrack audio_track) { m_audio_track = audio_track; }
+
+private:
+    u64 m_track_number { 0 };
+    u64 m_track_uid { 0 };
+    TrackType m_track_type { Invalid };
+    FlyString m_language = "eng";
+    FlyString m_codec_id;
+
+    union {
+        VideoTrack m_video_track {};
+        AudioTrack m_audio_track;
+    };
+};
+
+class Block {
+public:
+    enum Lacing : u8 {
+        None = 0b00,
+        XIPH = 0b01,
+        FixedSize = 0b10,
+        EBML = 0b11,
+    };
+
+    Block() = default;
+
+    u64 track_number() const { return m_track_number; }
+    void set_track_number(u64 track_number) { m_track_number = track_number; }
+    i16 timestamp() const { return m_timestamp; }
+    void set_timestamp(i16 timestamp) { m_timestamp = timestamp; }
+    bool only_keyframes() const { return m_only_keyframes; }
+    void set_only_keyframes(bool only_keyframes) { m_only_keyframes = only_keyframes; }
+    bool invisible() const { return m_invisible; }
+    void set_invisible(bool invisible) { m_invisible = invisible; }
+    Lacing lacing() const { return m_lacing; }
+    void set_lacing(Lacing lacing) { m_lacing = lacing; }
+    bool discardable() const { return m_discardable; }
+    void set_discardable(bool discardable) { m_discardable = discardable; }
+    u64 frame_count() const { return m_frames.size(); }
+    Vector<ByteBuffer> const& frames() const { return m_frames; }
+    ByteBuffer const& frame(size_t index) const { return frames()[index]; }
+    void add_frame(ByteBuffer frame) { m_frames.append(move(frame)); }
+
+private:
+    u64 m_track_number { 0 };
+    i16 m_timestamp { 0 };
+    bool m_only_keyframes { false };
+    bool m_invisible { false };
+    Lacing m_lacing { None };
+    bool m_discardable { true };
+    Vector<ByteBuffer> m_frames;
+};
+
+class Cluster {
+public:
+    u64 timestamp() const { return m_timestamp; }
+    void set_timestamp(u64 timestamp) { m_timestamp = timestamp; }
+    NonnullOwnPtrVector<Block>& blocks() { return m_blocks; }
+    NonnullOwnPtrVector<Block> const& blocks() const { return m_blocks; }
+
+private:
+    u64 m_timestamp { 0 };
+    NonnullOwnPtrVector<Block> m_blocks;
+};
+
+class MatroskaDocument {
+public:
+    explicit MatroskaDocument(EBMLHeader m_header)
+        : m_header(move(m_header))
+    {
+    }
+
+    EBMLHeader const& header() const { return m_header; }
+
+    Optional<SegmentInformation> segment_information() const
+    {
+        if (!m_segment_information)
+            return {};
+        return *m_segment_information;
+    }
+    void set_segment_information(OwnPtr<SegmentInformation> segment_information) { m_segment_information = move(segment_information); }
+    HashMap<u64, NonnullOwnPtr<TrackEntry>> const& tracks() const { return m_tracks; }
+    Optional<TrackEntry> track_for_track_number(u64 track_number) const
+    {
+        auto track = m_tracks.get(track_number);
+        if (!track.has_value())
+            return {};
+        return *track.value();
+    }
+    Optional<TrackEntry> track_for_track_type(TrackEntry::TrackType type) const
+    {
+        for (auto& track_entry : m_tracks) {
+            if (track_entry.value->track_type() == type)
+                return *track_entry.value;
+        }
+        return {};
+    }
+    void add_track(u64 track_number, NonnullOwnPtr<TrackEntry> track)
+    {
+        m_tracks.set(track_number, move(track));
+    }
+    NonnullOwnPtrVector<Cluster>& clusters() { return m_clusters; }
+
+private:
+    EBMLHeader m_header;
+    OwnPtr<SegmentInformation> m_segment_information;
+    HashMap<u64, NonnullOwnPtr<TrackEntry>> m_tracks;
+    NonnullOwnPtrVector<Cluster> m_clusters;
+};
+
+}