Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-08 06:09:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibVideo/Containers/Matroska/Reader.cpp

1123 lines
46 KiB
C++
Raw Normal View History

LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
/*
* Copyright (c) 2021, Hunter Salyer <thefalsehonesty@gmail.com>
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
* Copyright (c) 2022-2023, Gregory Bertilson <Zaggy1024@gmail.com>
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
Everywhere: Move AK/Debug.h include to using files or remove
2023-01-02 21:07:18 +01:00
#include <AK/Debug.h>
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
#include <AK/Function.h>
#include <AK/Optional.h>
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
#include <AK/Time.h>
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
#include <AK/Utf8View.h>
LibCore+AK: Move MappedFile from AK to LibCore MappedFile is strictly a userspace thing, so it doesn't belong in AK (which is supposed to be user/kernel agnostic.)
2021-11-23 11:32:25 +01:00
#include <LibCore/MappedFile.h>
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
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.
2022-11-09 19:47:56 -06:00
#include "Reader.h"
namespace Video::Matroska {
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
#define TRY_READ(expression) DECODER_TRY(DecoderErrorCategory::Corrupted, expression)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
// RFC 8794 - Extensible Binary Meta Language
// https://datatracker.ietf.org/doc/html/rfc8794
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
constexpr u32 EBML_MASTER_ELEMENT_ID = 0x1A45DFA3;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
constexpr u32 EBML_CRC32_ELEMENT_ID = 0xBF;
constexpr u32 EBML_VOID_ELEMENT_ID = 0xEC;
// Matroska elements' IDs and types are listed at this URL:
// https://www.matroska.org/technical/elements.html
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
constexpr u32 SEGMENT_ELEMENT_ID = 0x18538067;
constexpr u32 DOCTYPE_ELEMENT_ID = 0x4282;
constexpr u32 DOCTYPE_VERSION_ELEMENT_ID = 0x4287;
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
constexpr u32 SEEK_HEAD_ELEMENT_ID = 0x114D9B74;
constexpr u32 SEEK_ELEMENT_ID = 0x4DBB;
constexpr u32 SEEK_ID_ELEMENT_ID = 0x53AB;
constexpr u32 SEEK_POSITION_ELEMENT_ID = 0x53AC;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
constexpr u32 SEGMENT_INFORMATION_ELEMENT_ID = 0x1549A966;
constexpr u32 TRACK_ELEMENT_ID = 0x1654AE6B;
constexpr u32 CLUSTER_ELEMENT_ID = 0x1F43B675;
constexpr u32 TIMESTAMP_SCALE_ID = 0x2AD7B1;
constexpr u32 MUXING_APP_ID = 0x4D80;
constexpr u32 WRITING_APP_ID = 0x5741;
LibVideo: Parse the duration of Matroska files
2022-10-29 17:01:01 -05:00
constexpr u32 DURATION_ID = 0x4489;
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
// Tracks
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
constexpr u32 TRACK_ENTRY_ID = 0xAE;
constexpr u32 TRACK_NUMBER_ID = 0xD7;
constexpr u32 TRACK_UID_ID = 0x73C5;
constexpr u32 TRACK_TYPE_ID = 0x83;
constexpr u32 TRACK_LANGUAGE_ID = 0x22B59C;
constexpr u32 TRACK_CODEC_ID = 0x86;
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
constexpr u32 TRACK_TIMESTAMP_SCALE_ID = 0x23314F;
constexpr u32 TRACK_OFFSET_ID = 0x537F;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
constexpr u32 TRACK_VIDEO_ID = 0xE0;
constexpr u32 TRACK_AUDIO_ID = 0xE1;
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
// Video
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
constexpr u32 PIXEL_WIDTH_ID = 0xB0;
constexpr u32 PIXEL_HEIGHT_ID = 0xBA;
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
constexpr u32 COLOR_ENTRY_ID = 0x55B0;
constexpr u32 PRIMARIES_ID = 0x55BB;
constexpr u32 TRANSFER_CHARACTERISTICS_ID = 0x55BA;
constexpr u32 MATRIX_COEFFICIENTS_ID = 0x55B1;
constexpr u32 BITS_PER_CHANNEL_ID = 0x55B2;
// Audio
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
constexpr u32 CHANNELS_ID = 0x9F;
constexpr u32 BIT_DEPTH_ID = 0x6264;
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
// Clusters
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
constexpr u32 SIMPLE_BLOCK_ID = 0xA3;
constexpr u32 TIMESTAMP_ID = 0xE7;
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
// Cues
constexpr u32 CUES_ID = 0x1C53BB6B;
constexpr u32 CUE_POINT_ID = 0xBB;
constexpr u32 CUE_TIME_ID = 0xB3;
constexpr u32 CUE_TRACK_POSITIONS_ID = 0xB7;
constexpr u32 CUE_TRACK_ID = 0xF7;
constexpr u32 CUE_CLUSTER_POSITION_ID = 0xF1;
constexpr u32 CUE_RELATIVE_POSITION_ID = 0xF0;
constexpr u32 CUE_CODEC_STATE_ID = 0xEA;
constexpr u32 CUE_REFERENCE_ID = 0xDB;
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<Reader> Reader::from_file(StringView path)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
auto mapped_file = DECODER_TRY(DecoderErrorCategory::IO, Core::MappedFile::map(path));
LibCore: Make MappedFile OwnPtr-based Since it will become a stream in a little bit, it should behave like all non-trivial stream classes, who are not primarily intended to have shared ownership to make closing behavior more predictable. Across all uses of MappedFile, there is only one use case of shared mapped files in LibVideo, which now uses the thin SharedMappedFile wrapper.
2023-09-26 00:54:34 +02:00
return from_mapped_file(move(mapped_file));
LibVideo: Add `PlaybackManager::from_mapped_file` This allows us to create a PlaybackManager from a file which has already been mapped, instead of passing a file name. This means that anyone who uses `PlaybackManager` can now use LibFSAC :)
2023-05-11 12:25:52 +01:00
}
LibCore: Make MappedFile OwnPtr-based Since it will become a stream in a little bit, it should behave like all non-trivial stream classes, who are not primarily intended to have shared ownership to make closing behavior more predictable. Across all uses of MappedFile, there is only one use case of shared mapped files in LibVideo, which now uses the thin SharedMappedFile wrapper.
2023-09-26 00:54:34 +02:00
DecoderErrorOr<Reader> Reader::from_mapped_file(NonnullOwnPtr<Core::MappedFile> mapped_file)
LibVideo: Add `PlaybackManager::from_mapped_file` This allows us to create a PlaybackManager from a file which has already been mapped, instead of passing a file name. This means that anyone who uses `PlaybackManager` can now use LibFSAC :)
2023-05-11 12:25:52 +01:00
{
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
auto reader = TRY(from_data(mapped_file->bytes()));
LibCore: Make MappedFile OwnPtr-based Since it will become a stream in a little bit, it should behave like all non-trivial stream classes, who are not primarily intended to have shared ownership to make closing behavior more predictable. Across all uses of MappedFile, there is only one use case of shared mapped files in LibVideo, which now uses the thin SharedMappedFile wrapper.
2023-09-26 00:54:34 +02:00
reader.m_mapped_file = make_ref_counted<Core::SharedMappedFile>(move(mapped_file));
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return reader;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<Reader> Reader::from_data(ReadonlyBytes data)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Parse Matroska from ReadonlyBytes and keep the start position Keeping the entire Matroska stream available is a prerequisite to being able to stream from it and seek to cue points.
2022-11-10 16:58:53 -06:00
Reader reader(data);
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
TRY(reader.parse_initial_data());
return reader;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
// Returns the position of the first element that is read from this master element.
static DecoderErrorOr<size_t> parse_master_element(Streamer& streamer, [[maybe_unused]] StringView element_name, Function<DecoderErrorOr<IterationDecision>(u64)> element_consumer)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
auto element_data_size = TRY_READ(streamer.read_variable_size_integer());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
dbgln_if(MATROSKA_DEBUG, "{} has {} octets of data.", element_name, element_data_size);
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
bool first_element = true;
auto first_element_position = streamer.position();
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
streamer.push_octets_read();
while (streamer.octets_read() < element_data_size) {
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
dbgln_if(MATROSKA_TRACE_DEBUG, "====== Reading element ======");
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
auto element_id = TRY_READ(streamer.read_variable_size_integer(false));
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "{:s} element ID is {:#010x}", element_name, element_id);
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
if (element_id == EBML_CRC32_ELEMENT_ID) {
// The CRC-32 Element contains a 32-bit Cyclic Redundancy Check value of all the
// Element Data of the Parent Element as stored except for the CRC-32 Element itself.
// When the CRC-32 Element is present, the CRC-32 Element MUST be the first ordered
// EBML Element within its Parent Element for easier reading.
if (!first_element)
return DecoderError::corrupted("CRC32 element must be the first child"sv);
// All Top-Level Elements of an EBML Document that are Master Elements SHOULD include a
// CRC-32 Element as a Child Element. The CRC in use is the IEEE-CRC-32 algorithm as used
// in the [ISO3309] standard and in Section 8.1.1.6.2 of [ITU.V42], with initial value of
// 0xFFFFFFFF. The CRC value MUST be computed on a little-endian bytestream and MUST use
// little-endian storage.
// FIXME: Currently we skip the CRC-32 Element instead of checking it. It may be worth
// verifying the contents of the SeekHead, Segment Info, and Tracks Elements.
// Note that Cluster Elements tend to be quite large, so verifying their integrity
// will result in longer buffering times in streamed contexts, so it may not be
// worth the effort checking those. It would also prevent error correction in
// video codecs from taking effect.
TRY_READ(streamer.read_unknown_element());
continue;
}
if (element_id == EBML_VOID_ELEMENT_ID) {
// Used to void data or to avoid unexpected behaviors when using damaged data.
// The content is discarded. Also used to reserve space in a subelement for later use.
TRY_READ(streamer.read_unknown_element());
continue;
}
auto result = element_consumer(element_id);
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
if (result.is_error())
return DecoderError::format(result.error().category(), "{} -> {}", element_name, result.error().description());
if (result.release_value() == IterationDecision::Break)
break;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read {} octets of the {} so far.", streamer.octets_read(), element_name);
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
first_element = false;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
streamer.pop_octets_read();
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
return first_element_position;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
static DecoderErrorOr<EBMLHeader> parse_ebml_header(Streamer& streamer)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
EBMLHeader header;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "Header"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
switch (element_id) {
case DOCTYPE_ELEMENT_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
header.doc_type = TRY_READ(streamer.read_string());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
dbgln_if(MATROSKA_DEBUG, "Read DocType attribute: {}", header.doc_type);
break;
case DOCTYPE_VERSION_ELEMENT_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
header.doc_type_version = TRY_READ(streamer.read_u64());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
dbgln_if(MATROSKA_DEBUG, "Read DocTypeVersion attribute: {}", header.doc_type_version);
break;
default:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
TRY_READ(streamer.read_unknown_element());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
}));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
return header;
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<void> Reader::parse_initial_data()
{
Streamer streamer { m_data };
auto first_element_id = TRY_READ(streamer.read_variable_size_integer(false));
dbgln_if(MATROSKA_TRACE_DEBUG, "First element ID is {:#010x}\n", first_element_id);
if (first_element_id != EBML_MASTER_ELEMENT_ID)
return DecoderError::corrupted("First element was not an EBML header"sv);
m_header = TRY(parse_ebml_header(streamer));
dbgln_if(MATROSKA_DEBUG, "Parsed EBML header");
auto root_element_id = TRY_READ(streamer.read_variable_size_integer(false));
if (root_element_id != SEGMENT_ELEMENT_ID)
return DecoderError::corrupted("Second element was not a segment element"sv);
m_segment_contents_size = TRY_READ(streamer.read_variable_size_integer());
m_segment_contents_position = streamer.position();
dbgln_if(true, "Segment is at {} with size {}, available size is {}", m_segment_contents_position, m_segment_contents_size, m_data.size() - m_segment_contents_position);
m_segment_contents_size = min(m_segment_contents_size, m_data.size() - m_segment_contents_position);
return {};
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
static DecoderErrorOr<void> parse_seek_head(Streamer& streamer, size_t base_position, HashMap<u32, size_t>& table)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "SeekHead"sv, [&](u64 seek_head_child_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
if (seek_head_child_id == SEEK_ELEMENT_ID) {
Optional<u64> seek_id;
Optional<u64> seek_position;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "Seek"sv, [&](u64 seek_entry_child_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
switch (seek_entry_child_id) {
case SEEK_ID_ELEMENT_ID:
seek_id = TRY_READ(streamer.read_u64());
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Seek Element ID value {:#010x}", seek_id.value());
break;
case SEEK_POSITION_ELEMENT_ID:
seek_position = TRY_READ(streamer.read_u64());
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Seek Position value {}", seek_position.value());
break;
default:
TRY_READ(streamer.read_unknown_element());
}
return IterationDecision::Continue;
}));
if (!seek_id.has_value())
return DecoderError::corrupted("Seek entry is missing the element ID"sv);
if (!seek_position.has_value())
return DecoderError::corrupted("Seek entry is missing the seeking position"sv);
if (seek_id.value() > NumericLimits<u32>::max())
return DecoderError::corrupted("Seek entry's element ID is too large"sv);
dbgln_if(MATROSKA_TRACE_DEBUG, "Seek entry found with ID {:#010x} and position {} offset from SeekHead at {}", seek_id.value(), seek_position.value(), base_position);
// FIXME: SeekHead can reference another SeekHead, we should recursively parse all SeekHeads.
if (table.contains(seek_id.value())) {
dbgln_if(MATROSKA_DEBUG, "Warning: Duplicate seek entry with ID {:#010x} at position {}", seek_id.value(), seek_position.value());
return IterationDecision::Continue;
}
DECODER_TRY_ALLOC(table.try_set(seek_id.release_value(), base_position + seek_position.release_value()));
} else {
dbgln_if(MATROSKA_TRACE_DEBUG, "Unknown SeekHead child element ID {:#010x}", seek_head_child_id);
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
}));
return {};
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<Optional<size_t>> Reader::find_first_top_level_element_with_id([[maybe_unused]] StringView element_name, u32 element_id)
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
{
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
dbgln_if(MATROSKA_DEBUG, "====== Finding element {} with ID {:#010x} ======", element_name, element_id);
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
if (m_seek_entries.contains(element_id)) {
dbgln_if(MATROSKA_TRACE_DEBUG, "Cache hit!");
return m_seek_entries.get(element_id).release_value();
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
Streamer streamer { m_data };
if (m_last_top_level_element_position != 0)
TRY_READ(streamer.seek_to_position(m_last_top_level_element_position));
else
TRY_READ(streamer.seek_to_position(m_segment_contents_position));
Optional<size_t> position;
while (streamer.position() < m_segment_contents_position + m_segment_contents_size) {
auto found_element_id = TRY_READ(streamer.read_variable_size_integer(false));
auto found_element_position = streamer.position();
dbgln_if(MATROSKA_TRACE_DEBUG, "Found element ID {:#010x} with position {}.", found_element_id, found_element_position);
if (found_element_id == SEEK_HEAD_ELEMENT_ID) {
dbgln_if(MATROSKA_TRACE_DEBUG, "Found SeekHead, parsing it into the lookup table.");
m_seek_entries.clear();
TRY(parse_seek_head(streamer, found_element_position, m_seek_entries));
m_last_top_level_element_position = 0;
if (m_seek_entries.contains(element_id)) {
dbgln_if(MATROSKA_TRACE_DEBUG, "SeekHead hit!");
position = m_seek_entries.get(element_id).release_value();
break;
}
continue;
}
auto result = streamer.read_unknown_element();
if (result.is_error())
return DecoderError::format(DecoderErrorCategory::Corrupted, "While seeking to {}: {}", element_name, result.release_error().string_literal());
m_last_top_level_element_position = streamer.position();
DECODER_TRY_ALLOC(m_seek_entries.try_set(found_element_id, found_element_position));
if (found_element_id == element_id) {
position = found_element_position;
break;
}
dbgln_if(MATROSKA_TRACE_DEBUG, "Skipped to position {}.", m_last_top_level_element_position);
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return position;
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
static DecoderErrorOr<SegmentInformation> parse_information(Streamer& streamer)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
SegmentInformation segment_information;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "Segment Information"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
switch (element_id) {
case TIMESTAMP_SCALE_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
segment_information.set_timestamp_scale(TRY_READ(streamer.read_u64()));
dbgln_if(MATROSKA_DEBUG, "Read TimestampScale attribute: {}", segment_information.timestamp_scale());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
break;
case MUXING_APP_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
segment_information.set_muxing_app(TRY_READ(streamer.read_string()));
dbgln_if(MATROSKA_DEBUG, "Read MuxingApp attribute: {}", segment_information.muxing_app().as_string());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
break;
case WRITING_APP_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
segment_information.set_writing_app(TRY_READ(streamer.read_string()));
dbgln_if(MATROSKA_DEBUG, "Read WritingApp attribute: {}", segment_information.writing_app().as_string());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
break;
case DURATION_ID:
LibVideo: Give Matroska duration an absolute value getter Previously, the duration had to be multiplied by timestamp_scale and converted to a Time object, now SegmentInformation::duration() does it itself.
2022-11-13 19:13:50 -06:00
segment_information.set_duration_unscaled(TRY_READ(streamer.read_float()));
dbgln_if(MATROSKA_DEBUG, "Read Duration attribute: {}", segment_information.duration_unscaled().value());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
break;
default:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
TRY_READ(streamer.read_unknown_element());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
}));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
return segment_information;
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<SegmentInformation> Reader::segment_information()
{
if (m_segment_information.has_value())
return m_segment_information.value();
auto position = TRY(find_first_top_level_element_with_id("Segment Information"sv, SEGMENT_INFORMATION_ELEMENT_ID));
if (!position.has_value())
return DecoderError::corrupted("No Segment Information element found"sv);
Streamer streamer { m_data };
TRY_READ(streamer.seek_to_position(position.release_value()));
m_segment_information = TRY(parse_information(streamer));
return m_segment_information.value();
}
DecoderErrorOr<void> Reader::ensure_tracks_are_parsed()
{
if (!m_tracks.is_empty())
return {};
auto position = TRY(find_first_top_level_element_with_id("Tracks"sv, TRACK_ELEMENT_ID));
if (!position.has_value())
return DecoderError::corrupted("No Tracks element found"sv);
Streamer streamer { m_data };
TRY_READ(streamer.seek_to_position(position.release_value()));
TRY(parse_tracks(streamer));
return {};
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
static DecoderErrorOr<TrackEntry::ColorFormat> parse_video_color_information(Streamer& streamer)
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
{
TrackEntry::ColorFormat color_format {};
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "Colour"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
switch (element_id) {
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
case PRIMARIES_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
color_format.color_primaries = static_cast<ColorPrimaries>(TRY_READ(streamer.read_u64()));
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Colour's Primaries attribute: {}", color_primaries_to_string(color_format.color_primaries));
break;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
case TRANSFER_CHARACTERISTICS_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
color_format.transfer_characteristics = static_cast<TransferCharacteristics>(TRY_READ(streamer.read_u64()));
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Colour's TransferCharacteristics attribute: {}", transfer_characteristics_to_string(color_format.transfer_characteristics));
break;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
case MATRIX_COEFFICIENTS_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
color_format.matrix_coefficients = static_cast<MatrixCoefficients>(TRY_READ(streamer.read_u64()));
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Colour's MatrixCoefficients attribute: {}", matrix_coefficients_to_string(color_format.matrix_coefficients));
break;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
case BITS_PER_CHANNEL_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
color_format.bits_per_channel = TRY_READ(streamer.read_u64());
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Colour's BitsPerChannel attribute: {}", color_format.bits_per_channel);
break;
default:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
TRY_READ(streamer.read_unknown_element());
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
}));
LibVideo: Add CICP parsing to MatroskaReader This will allow correct independent code points to be selected from VP9 in WebM, since the VP9 bitstream does not specify them independently.
2022-10-10 05:04:28 -05:00
return color_format;
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
static DecoderErrorOr<TrackEntry::VideoTrack> parse_video_track_information(Streamer& streamer)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
TrackEntry::VideoTrack video_track {};
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "VideoTrack"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
switch (element_id) {
case PIXEL_WIDTH_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
video_track.pixel_width = TRY_READ(streamer.read_u64());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read VideoTrack's PixelWidth attribute: {}", video_track.pixel_width);
break;
case PIXEL_HEIGHT_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
video_track.pixel_height = TRY_READ(streamer.read_u64());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read VideoTrack's PixelHeight attribute: {}", video_track.pixel_height);
break;
case COLOR_ENTRY_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
video_track.color_format = TRY(parse_video_color_information(streamer));
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
break;
default:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
TRY_READ(streamer.read_unknown_element());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
}));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
return video_track;
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
static DecoderErrorOr<TrackEntry::AudioTrack> parse_audio_track_information(Streamer& streamer)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
TrackEntry::AudioTrack audio_track {};
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "AudioTrack"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
switch (element_id) {
case CHANNELS_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
audio_track.channels = TRY_READ(streamer.read_u64());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read AudioTrack's Channels attribute: {}", audio_track.channels);
break;
case BIT_DEPTH_ID:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
audio_track.bit_depth = TRY_READ(streamer.read_u64());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read AudioTrack's BitDepth attribute: {}", audio_track.bit_depth);
break;
default:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
TRY_READ(streamer.read_unknown_element());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
}));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
return audio_track;
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
static DecoderErrorOr<TrackEntry> parse_track_entry(Streamer& streamer)
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
{
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
TrackEntry track_entry;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "Track"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
switch (element_id) {
case TRACK_NUMBER_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
track_entry.set_track_number(TRY_READ(streamer.read_u64()));
dbgln_if(MATROSKA_TRACE_DEBUG, "Read TrackNumber attribute: {}", track_entry.track_number());
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
break;
case TRACK_UID_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
track_entry.set_track_uid(TRY_READ(streamer.read_u64()));
dbgln_if(MATROSKA_TRACE_DEBUG, "Read TrackUID attribute: {}", track_entry.track_uid());
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
break;
case TRACK_TYPE_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
track_entry.set_track_type(static_cast<TrackEntry::TrackType>(TRY_READ(streamer.read_u64())));
dbgln_if(MATROSKA_TRACE_DEBUG, "Read TrackType attribute: {}", to_underlying(track_entry.track_type()));
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
break;
case TRACK_LANGUAGE_ID:
LibVideo: Replace DeprecatedFlyString with FlyString
2024-01-02 15:45:53 +01:00
track_entry.set_language(DECODER_TRY_ALLOC(FlyString::from_utf8(TRY_READ(streamer.read_string()).view())));
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Track's Language attribute: {}", track_entry.language());
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
break;
case TRACK_CODEC_ID:
LibVideo: Replace DeprecatedFlyString with FlyString
2024-01-02 15:45:53 +01:00
track_entry.set_codec_id(DECODER_TRY_ALLOC(FlyString::from_utf8(TRY_READ(streamer.read_string()).view())));
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Track's CodecID attribute: {}", track_entry.codec_id());
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
break;
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
case TRACK_TIMESTAMP_SCALE_ID:
track_entry.set_timestamp_scale(TRY_READ(streamer.read_float()));
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Track's TrackTimestampScale attribute: {}", track_entry.timestamp_scale());
break;
case TRACK_OFFSET_ID:
track_entry.set_timestamp_offset(TRY_READ(streamer.read_variable_size_signed_integer()));
dbgln_if(MATROSKA_TRACE_DEBUG, "Read Track's TrackOffset attribute: {}", track_entry.timestamp_offset());
break;
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
case TRACK_VIDEO_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
track_entry.set_video_track(TRY(parse_video_track_information(streamer)));
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
break;
case TRACK_AUDIO_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
track_entry.set_audio_track(TRY(parse_audio_track_information(streamer)));
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
break;
default:
TRY_READ(streamer.read_unknown_element());
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
}));
return track_entry;
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<void> Reader::parse_tracks(Streamer& streamer)
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
{
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "Tracks"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
if (element_id == TRACK_ENTRY_ID) {
auto track_entry = TRY(parse_track_entry(streamer));
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
dbgln_if(MATROSKA_DEBUG, "Parsed track {}", track_entry.track_number());
DECODER_TRY_ALLOC(m_tracks.try_set(track_entry.track_number(), track_entry));
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
} else {
TRY_READ(streamer.read_unknown_element());
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
}));
return {};
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<void> Reader::for_each_track(TrackEntryCallback callback)
{
TRY(ensure_tracks_are_parsed());
for (auto const& track_entry : m_tracks) {
auto decision = TRY(callback(track_entry.value));
if (decision == IterationDecision::Break)
break;
}
return {};
}
DecoderErrorOr<void> Reader::for_each_track_of_type(TrackEntry::TrackType type, TrackEntryCallback callback)
{
return for_each_track([&](TrackEntry const& track_entry) -> DecoderErrorOr<IterationDecision> {
if (track_entry.track_type() != type)
return IterationDecision::Continue;
return callback(track_entry);
});
}
DecoderErrorOr<TrackEntry> Reader::track_for_track_number(u64 track_number)
{
TRY(ensure_tracks_are_parsed());
auto optional_track_entry = m_tracks.get(track_number);
if (!optional_track_entry.has_value())
return DecoderError::format(DecoderErrorCategory::Invalid, "No track found with number {}", track_number);
return optional_track_entry.release_value();
}
DecoderErrorOr<size_t> Reader::track_count()
{
TRY(ensure_tracks_are_parsed());
return m_tracks.size();
}
constexpr size_t get_element_id_size(u32 element_id)
{
return sizeof(element_id) - (count_leading_zeroes(element_id) / 8);
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
LibVideo: Make Matroska Block and Cluster timestamps absolute
2022-11-12 02:28:15 -06:00
static DecoderErrorOr<Cluster> parse_cluster(Streamer& streamer, u64 timestamp_scale)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
Optional<u64> timestamp;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
auto first_element_position = TRY(parse_master_element(streamer, "Cluster"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
switch (element_id) {
case TIMESTAMP_ID:
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
timestamp = TRY_READ(streamer.read_u64());
return IterationDecision::Break;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
default:
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
TRY_READ(streamer.read_unknown_element());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return IterationDecision::Continue;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
}));
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
if (!timestamp.has_value())
return DecoderError::corrupted("Cluster was missing a timestamp"sv);
if (first_element_position == 0)
return DecoderError::corrupted("Cluster had no children"sv);
dbgln_if(MATROSKA_TRACE_DEBUG, "Seeking back to position {}", first_element_position);
TRY_READ(streamer.seek_to_position(first_element_position));
Cluster cluster;
AK: Rename Time to Duration That's what this class really is; in fact that's what the first line of the comment says it is. This commit does not rename the main files, since those will contain other time-related classes in a little bit.
2023-03-13 16:30:34 +01:00
cluster.set_timestamp(Duration::from_nanoseconds(timestamp.release_value() * timestamp_scale));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
return cluster;
}
AK: Rename Time to Duration That's what this class really is; in fact that's what the first line of the comment says it is. This commit does not rename the main files, since those will contain other time-related classes in a little bit.
2023-03-13 16:30:34 +01:00
static DecoderErrorOr<Block> parse_simple_block(Streamer& streamer, Duration cluster_timestamp, u64 segment_timestamp_scale, TrackEntry track)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
Block block;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
auto content_size = TRY_READ(streamer.read_variable_size_integer());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
auto position_before_track_number = streamer.position();
block.set_track_number(TRY_READ(streamer.read_variable_size_integer()));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
// https://www.matroska.org/technical/notes.html
// Block Timestamps:
// The Block Element and SimpleBlock Element store their timestamps as signed integers,
// relative to the Cluster\Timestamp value of the Cluster they are stored in. To get the
// timestamp of a Block or SimpleBlock in nanoseconds you have to use the following formula:
// `( Cluster\Timestamp + ( block timestamp * TrackTimestampScale ) ) * TimestampScale`
//
LibVideo: Fix two comment typos
2022-12-26 08:26:09 -05:00
// When a CodecDelay Element is set, its value MUST be subtracted from each Block timestamp
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
// of that track. To get the timestamp in nanoseconds of the first frame in a Block or
// SimpleBlock, the formula becomes:
// `( ( Cluster\Timestamp + ( block timestamp * TrackTimestampScale ) ) * TimestampScale ) - CodecDelay`
AK: Rename Time to Duration That's what this class really is; in fact that's what the first line of the comment says it is. This commit does not rename the main files, since those will contain other time-related classes in a little bit.
2023-03-13 16:30:34 +01:00
Duration timestamp_offset = Duration::from_nanoseconds(static_cast<i64>(static_cast<double>(TRY_READ(streamer.read_i16()) * segment_timestamp_scale) * track.timestamp_scale()));
timestamp_offset -= Duration::from_nanoseconds(static_cast<i64>(track.codec_delay()));
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
// This is only mentioned in the elements specification under TrackOffset.
// https://www.matroska.org/technical/elements.html
AK: Rename Time to Duration That's what this class really is; in fact that's what the first line of the comment says it is. This commit does not rename the main files, since those will contain other time-related classes in a little bit.
2023-03-13 16:30:34 +01:00
timestamp_offset += Duration::from_nanoseconds(static_cast<i64>(track.timestamp_offset()));
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
block.set_timestamp(cluster_timestamp + timestamp_offset);
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
auto flags = TRY_READ(streamer.read_octet());
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
block.set_only_keyframes((flags & (1u << 7u)) != 0);
block.set_invisible((flags & (1u << 3u)) != 0);
block.set_lacing(static_cast<Block::Lacing>((flags & 0b110u) >> 1u));
block.set_discardable((flags & 1u) != 0);
auto total_frame_content_size = content_size - (streamer.position() - position_before_track_number);
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
Vector<ReadonlyBytes> frames;
if (block.lacing() == Block::Lacing::EBML) {
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
auto octets_read_before_frame_sizes = streamer.octets_read();
auto frame_count = TRY_READ(streamer.read_octet()) + 1;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
Vector<u64> frame_sizes;
frame_sizes.ensure_capacity(frame_count);
u64 frame_size_sum = 0;
u64 previous_frame_size;
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
auto first_frame_size = TRY_READ(streamer.read_variable_size_integer());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
frame_sizes.append(first_frame_size);
frame_size_sum += first_frame_size;
previous_frame_size = first_frame_size;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
for (int i = 0; i < frame_count - 2; i++) {
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
auto frame_size_difference = TRY_READ(streamer.read_variable_size_signed_integer());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
u64 frame_size;
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
// FIXME: x - (-y) == x + y?
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
if (frame_size_difference < 0)
frame_size = previous_frame_size - (-frame_size_difference);
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
else
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
frame_size = previous_frame_size + frame_size_difference;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
frame_sizes.append(frame_size);
frame_size_sum += frame_size;
previous_frame_size = frame_size;
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
frame_sizes.append(total_frame_content_size - frame_size_sum - (streamer.octets_read() - octets_read_before_frame_sizes));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
for (int i = 0; i < frame_count; i++) {
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
// FIXME: ReadonlyBytes instead of copying the frame data?
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
auto current_frame_size = frame_sizes.at(i);
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
frames.append(TRY_READ(streamer.read_raw_octets(current_frame_size)));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
} else if (block.lacing() == Block::Lacing::FixedSize) {
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
auto frame_count = TRY_READ(streamer.read_octet()) + 1;
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
auto individual_frame_size = total_frame_content_size / frame_count;
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
for (int i = 0; i < frame_count; i++)
frames.append(TRY_READ(streamer.read_raw_octets(individual_frame_size)));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
} else {
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
frames.append(TRY_READ(streamer.read_raw_octets(total_frame_content_size)));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
block.set_frames(move(frames));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
return block;
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<SampleIterator> Reader::create_sample_iterator(u64 track_number)
{
auto optional_position = TRY(find_first_top_level_element_with_id("Cluster"sv, CLUSTER_ELEMENT_ID));
if (!optional_position.has_value())
return DecoderError::corrupted("No clusters are present in the segment"sv);
ReadonlyBytes segment_view = m_data.slice(m_segment_contents_position, m_segment_contents_size);
// We need to have the element ID included so that the iterator knows where it is.
auto position = optional_position.value() - get_element_id_size(CLUSTER_ELEMENT_ID) - m_segment_contents_position;
dbgln_if(MATROSKA_DEBUG, "Creating sample iterator starting at {} relative to segment at {}", position, m_segment_contents_position);
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
return SampleIterator(this->m_mapped_file, segment_view, TRY(track_for_track_number(track_number)), TRY(segment_information()).timestamp_scale(), position);
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
}
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
static DecoderErrorOr<CueTrackPosition> parse_cue_track_position(Streamer& streamer)
{
CueTrackPosition track_position;
bool had_cluster_position = false;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY_READ(parse_master_element(streamer, "CueTrackPositions"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
switch (element_id) {
case CUE_TRACK_ID:
track_position.set_track_number(TRY_READ(streamer.read_u64()));
dbgln_if(MATROSKA_TRACE_DEBUG, "Read CueTrackPositions track number {}", track_position.track_number());
break;
case CUE_CLUSTER_POSITION_ID:
track_position.set_cluster_position(TRY_READ(streamer.read_u64()));
dbgln_if(MATROSKA_TRACE_DEBUG, "Read CueTrackPositions cluster position {}", track_position.cluster_position());
had_cluster_position = true;
break;
case CUE_RELATIVE_POSITION_ID:
track_position.set_block_offset(TRY_READ(streamer.read_u64()));
dbgln_if(MATROSKA_TRACE_DEBUG, "Read CueTrackPositions relative position {}", track_position.block_offset());
break;
case CUE_CODEC_STATE_ID:
// Mandatory in spec, but not present in files? 0 means use TrackEntry's codec state.
// FIXME: Do something with this value.
dbgln_if(MATROSKA_DEBUG, "Found CodecState, skipping");
TRY_READ(streamer.read_unknown_element());
break;
case CUE_REFERENCE_ID:
return DecoderError::not_implemented();
default:
TRY_READ(streamer.read_unknown_element());
break;
}
return IterationDecision::Continue;
}));
if (track_position.track_number() == 0)
return DecoderError::corrupted("Track number was not present or 0"sv);
if (!had_cluster_position)
return DecoderError::corrupted("Cluster was missing the cluster position"sv);
return track_position;
}
static DecoderErrorOr<CuePoint> parse_cue_point(Streamer& streamer, u64 timestamp_scale)
{
CuePoint cue_point;
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "CuePoint"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
switch (element_id) {
case CUE_TIME_ID: {
// On https://www.matroska.org/technical/elements.html, spec says of the CueTime element:
// > Absolute timestamp of the seek point, expressed in Matroska Ticks -- ie in nanoseconds; see timestamp-ticks.
// Matroska Ticks are specified in https://www.matroska.org/technical/notes.html:
// > For such elements, the timestamp value is stored directly in nanoseconds.
// However, my test files appear to use Segment Ticks, which uses the segment's timestamp scale, and Mozilla's nestegg parser agrees:
// https://github.com/mozilla/nestegg/tree/ec6adfbbf979678e3058cc4695257366f39e290b/src/nestegg.c#L1941
// https://github.com/mozilla/nestegg/tree/ec6adfbbf979678e3058cc4695257366f39e290b/src/nestegg.c#L2411-L2416
// https://github.com/mozilla/nestegg/tree/ec6adfbbf979678e3058cc4695257366f39e290b/src/nestegg.c#L1383-L1392
// Other fields that specify Matroska Ticks may also use Segment Ticks instead, who knows :^(
AK: Rename Time to Duration That's what this class really is; in fact that's what the first line of the comment says it is. This commit does not rename the main files, since those will contain other time-related classes in a little bit.
2023-03-13 16:30:34 +01:00
auto timestamp = Duration::from_nanoseconds(static_cast<i64>(TRY_READ(streamer.read_u64()) * timestamp_scale));
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
cue_point.set_timestamp(timestamp);
dbgln_if(MATROSKA_DEBUG, "Read CuePoint timestamp {}ms", cue_point.timestamp().to_milliseconds());
break;
}
case CUE_TRACK_POSITIONS_ID: {
auto track_position = TRY_READ(parse_cue_track_position(streamer));
DECODER_TRY_ALLOC(cue_point.track_positions().try_set(track_position.track_number(), track_position));
break;
}
default:
TRY_READ(streamer.read_unknown_element());
break;
}
return IterationDecision::Continue;
}));
if (cue_point.timestamp().is_negative())
return DecoderError::corrupted("CuePoint was missing a timestamp"sv);
if (cue_point.track_positions().is_empty())
return DecoderError::corrupted("CuePoint was missing track positions"sv);
return cue_point;
}
DecoderErrorOr<void> Reader::parse_cues(Streamer& streamer)
{
m_cues.clear();
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
TRY(parse_master_element(streamer, "Cues"sv, [&](u64 element_id) -> DecoderErrorOr<IterationDecision> {
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
switch (element_id) {
case CUE_POINT_ID: {
auto cue_point = TRY(parse_cue_point(streamer, TRY(segment_information()).timestamp_scale()));
// FIXME: Verify that these are already in order of timestamp. If they are not, return a corrupted error for now,
// but if it turns out that Matroska files with out-of-order cue points are valid, sort them instead.
for (auto track_position_entry : cue_point.track_positions()) {
if (!m_cues.contains(track_position_entry.key))
DECODER_TRY_ALLOC(m_cues.try_set(track_position_entry.key, Vector<CuePoint>()));
Vector<CuePoint>& cue_points_for_track = m_cues.get(track_position_entry.key).release_value();
cue_points_for_track.append(cue_point);
}
break;
}
default:
return DecoderError::format(DecoderErrorCategory::Corrupted, "Unknown Cues child ID {:#010x}", element_id);
}
return IterationDecision::Continue;
}));
return {};
}
DecoderErrorOr<void> Reader::ensure_cues_are_parsed()
{
if (m_cues_have_been_parsed)
return {};
auto position = TRY(find_first_top_level_element_with_id("Cues"sv, CUES_ID));
if (!position.has_value())
return DecoderError::corrupted("No Tracks element found"sv);
Streamer streamer { m_data };
TRY_READ(streamer.seek_to_position(position.release_value()));
TRY(parse_cues(streamer));
m_cues_have_been_parsed = true;
return {};
}
AK: Rename Time to Duration That's what this class really is; in fact that's what the first line of the comment says it is. This commit does not rename the main files, since those will contain other time-related classes in a little bit.
2023-03-13 16:30:34 +01:00
DecoderErrorOr<void> Reader::seek_to_cue_for_timestamp(SampleIterator& iterator, Duration const& timestamp)
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
{
auto const& cue_points = MUST(cue_points_for_track(iterator.m_track.track_number())).release_value();
// Take a guess at where in the cues the timestamp will be and correct from there.
auto duration = TRY(segment_information()).duration();
size_t index = 0;
if (duration.has_value())
index = clamp(((timestamp.to_nanoseconds() * cue_points.size()) / TRY(segment_information()).duration()->to_nanoseconds()), 0, cue_points.size() - 1);
CuePoint const* prev_cue_point = &cue_points[index];
LibVideo/Matroska: Add debug logging for seeking to cues
2023-02-05 17:45:56 -06:00
dbgln_if(MATROSKA_DEBUG, "Finding Matroska cue points for timestamp {}ms starting from cue at {}ms", timestamp.to_milliseconds(), prev_cue_point->timestamp().to_milliseconds());
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
if (prev_cue_point->timestamp() == timestamp) {
TRY(iterator.seek_to_cue_point(*prev_cue_point));
return {};
}
if (prev_cue_point->timestamp() > timestamp) {
LibVideo/Matroska: Add debug logging for seeking to cues
2023-02-05 17:45:56 -06:00
while (index > 0 && prev_cue_point->timestamp() > timestamp) {
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
prev_cue_point = &cue_points[--index];
LibVideo/Matroska: Add debug logging for seeking to cues
2023-02-05 17:45:56 -06:00
dbgln_if(MATROSKA_DEBUG, "Checking previous cue point {}ms", prev_cue_point->timestamp().to_milliseconds());
}
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
TRY(iterator.seek_to_cue_point(*prev_cue_point));
return {};
}
LibVideo/Matroska: Fix out-of-bounds access when seeking to cues
2023-02-11 20:08:09 -06:00
while (++index < cue_points.size()) {
auto const& cue_point = cue_points[index];
LibVideo/Matroska: Add debug logging for seeking to cues
2023-02-05 17:45:56 -06:00
dbgln_if(MATROSKA_DEBUG, "Checking future cue point {}ms", cue_point.timestamp().to_milliseconds());
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
if (cue_point.timestamp() > timestamp)
break;
prev_cue_point = &cue_point;
}
TRY(iterator.seek_to_cue_point(*prev_cue_point));
return {};
}
AK: Rename Time to Duration That's what this class really is; in fact that's what the first line of the comment says it is. This commit does not rename the main files, since those will contain other time-related classes in a little bit.
2023-03-13 16:30:34 +01:00
static DecoderErrorOr<void> search_clusters_for_keyframe_before_timestamp(SampleIterator& iterator, Duration const& timestamp)
LibVideo: Implement Matroska keyframe search for when there are no Cues This just searches sequentially through each block in a SampleIterator until it finds a block after the specified seek timestamp. Once it finds one, it will try to set the input/output iterator to the most recent keyframe. If the iterator's original position is closer to the target, however, it leaves it at that original position, allowing callers to continue decoding from that position until they reach the target timestamp.
2022-11-12 04:04:13 -06:00
{
#if MATROSKA_DEBUG
size_t inter_frames_count;
#endif
Optional<SampleIterator> last_keyframe;
while (true) {
SampleIterator rewind_iterator = iterator;
auto block = TRY(iterator.next_block());
if (block.only_keyframes()) {
last_keyframe.emplace(rewind_iterator);
#if MATROSKA_DEBUG
inter_frames_count = 0;
#endif
}
if (block.timestamp() > timestamp)
break;
#if MATROSKA_DEBUG
inter_frames_count++;
#endif
}
if (last_keyframe.has_value()) {
#if MATROSKA_DEBUG
dbgln("Seeked to a keyframe with {} inter frames to skip", inter_frames_count);
#endif
iterator = last_keyframe.release_value();
}
LibVideo: Pass the current sample to demuxers to lazily seek better In cases where the PlaybackManager's earliest buffered or displayed sample is closer to the seek target than the demuxer's chosen keyframe, we don't want to seek at all. To enable this, demuxers now receive an optional parameter with the earliest timestamp that the caller can still access. The demuxer in turn returns an optional to indicate when a seek was not needed, which allows PlaybackManager to avoid clearing its queue and re-decoding frames.
2023-02-06 01:25:02 -06:00
return {};
LibVideo: Implement Matroska keyframe search for when there are no Cues This just searches sequentially through each block in a SampleIterator until it finds a block after the specified seek timestamp. Once it finds one, it will try to set the input/output iterator to the most recent keyframe. If the iterator's original position is closer to the target, however, it leaves it at that original position, allowing callers to continue decoding from that position until they reach the target timestamp.
2022-11-12 04:04:13 -06:00
}
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
DecoderErrorOr<bool> Reader::has_cues_for_track(u64 track_number)
{
TRY(ensure_cues_are_parsed());
return m_cues.contains(track_number);
}
AK: Rename Time to Duration That's what this class really is; in fact that's what the first line of the comment says it is. This commit does not rename the main files, since those will contain other time-related classes in a little bit.
2023-03-13 16:30:34 +01:00
DecoderErrorOr<SampleIterator> Reader::seek_to_random_access_point(SampleIterator iterator, Duration timestamp)
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
{
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
if (TRY(has_cues_for_track(iterator.m_track.track_number()))) {
LibVideo: Pass the current sample to demuxers to lazily seek better In cases where the PlaybackManager's earliest buffered or displayed sample is closer to the seek target than the demuxer's chosen keyframe, we don't want to seek at all. To enable this, demuxers now receive an optional parameter with the earliest timestamp that the caller can still access. The demuxer in turn returns an optional to indicate when a seek was not needed, which allows PlaybackManager to avoid clearing its queue and re-decoding frames.
2023-02-06 01:25:02 -06:00
TRY(seek_to_cue_for_timestamp(iterator, timestamp));
LibVideo/Matroska: Remove assertion that cue seeks find earlier samples Files can contain a first keyframe that is timestamped later than zero. We don't want to crash in those cases, so don't assert that it can't happen.
2023-04-12 04:36:58 -05:00
VERIFY(iterator.last_timestamp().has_value());
LibVideo: Pass the current sample to demuxers to lazily seek better In cases where the PlaybackManager's earliest buffered or displayed sample is closer to the seek target than the demuxer's chosen keyframe, we don't want to seek at all. To enable this, demuxers now receive an optional parameter with the earliest timestamp that the caller can still access. The demuxer in turn returns an optional to indicate when a seek was not needed, which allows PlaybackManager to avoid clearing its queue and re-decoding frames.
2023-02-06 01:25:02 -06:00
return iterator;
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
}
LibVideo: Implement Matroska keyframe search for when there are no Cues This just searches sequentially through each block in a SampleIterator until it finds a block after the specified seek timestamp. Once it finds one, it will try to set the input/output iterator to the most recent keyframe. If the iterator's original position is closer to the target, however, it leaves it at that original position, allowing callers to continue decoding from that position until they reach the target timestamp.
2022-11-12 04:04:13 -06:00
LibVideo: Pass the current sample to demuxers to lazily seek better In cases where the PlaybackManager's earliest buffered or displayed sample is closer to the seek target than the demuxer's chosen keyframe, we don't want to seek at all. To enable this, demuxers now receive an optional parameter with the earliest timestamp that the caller can still access. The demuxer in turn returns an optional to indicate when a seek was not needed, which allows PlaybackManager to avoid clearing its queue and re-decoding frames.
2023-02-06 01:25:02 -06:00
if (!iterator.last_timestamp().has_value() || timestamp < iterator.last_timestamp().value()) {
LibVideo: Implement Matroska keyframe search for when there are no Cues This just searches sequentially through each block in a SampleIterator until it finds a block after the specified seek timestamp. Once it finds one, it will try to set the input/output iterator to the most recent keyframe. If the iterator's original position is closer to the target, however, it leaves it at that original position, allowing callers to continue decoding from that position until they reach the target timestamp.
2022-11-12 04:04:13 -06:00
// If the timestamp is before the iterator's current position, then we need to start from the beginning of the Segment.
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
iterator = TRY(create_sample_iterator(iterator.m_track.track_number()));
LibVideo: Pass the current sample to demuxers to lazily seek better In cases where the PlaybackManager's earliest buffered or displayed sample is closer to the seek target than the demuxer's chosen keyframe, we don't want to seek at all. To enable this, demuxers now receive an optional parameter with the earliest timestamp that the caller can still access. The demuxer in turn returns an optional to indicate when a seek was not needed, which allows PlaybackManager to avoid clearing its queue and re-decoding frames.
2023-02-06 01:25:02 -06:00
TRY(search_clusters_for_keyframe_before_timestamp(iterator, timestamp));
return iterator;
LibVideo: Implement Matroska keyframe search for when there are no Cues This just searches sequentially through each block in a SampleIterator until it finds a block after the specified seek timestamp. Once it finds one, it will try to set the input/output iterator to the most recent keyframe. If the iterator's original position is closer to the target, however, it leaves it at that original position, allowing callers to continue decoding from that position until they reach the target timestamp.
2022-11-12 04:04:13 -06:00
}
LibVideo: Pass the current sample to demuxers to lazily seek better In cases where the PlaybackManager's earliest buffered or displayed sample is closer to the seek target than the demuxer's chosen keyframe, we don't want to seek at all. To enable this, demuxers now receive an optional parameter with the earliest timestamp that the caller can still access. The demuxer in turn returns an optional to indicate when a seek was not needed, which allows PlaybackManager to avoid clearing its queue and re-decoding frames.
2023-02-06 01:25:02 -06:00
TRY(search_clusters_for_keyframe_before_timestamp(iterator, timestamp));
return iterator;
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
}
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
DecoderErrorOr<Optional<Vector<CuePoint> const&>> Reader::cue_points_for_track(u64 track_number)
{
TRY(ensure_cues_are_parsed());
return m_cues.get(track_number);
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
DecoderErrorOr<Block> SampleIterator::next_block()
{
if (m_position >= m_data.size())
return DecoderError::with_description(DecoderErrorCategory::EndOfStream, "Still at end of stream :^)"sv);
Streamer streamer { m_data };
TRY_READ(streamer.seek_to_position(m_position));
Optional<Block> block;
while (streamer.has_octet()) {
#if MATROSKA_TRACE_DEBUG
auto element_position = streamer.position();
#endif
auto element_id = TRY_READ(streamer.read_variable_size_integer(false));
#if MATROSKA_TRACE_DEBUG
dbgln("Iterator found element with ID {:#010x} at offset {} within the segment.", element_id, element_position);
#endif
if (element_id == CLUSTER_ELEMENT_ID) {
dbgln_if(MATROSKA_DEBUG, " Iterator is parsing new cluster.");
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
m_current_cluster = TRY(parse_cluster(streamer, m_segment_timestamp_scale));
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
} else if (element_id == SIMPLE_BLOCK_ID) {
dbgln_if(MATROSKA_TRACE_DEBUG, " Iterator is parsing new block.");
LibVideo: Calculate Block timestamps for Matroska according to spec Tracks have a timestamp scale value that should be present which scales each block's timestamp offset to allow video to be synced with audio. They should also contain a CodecDelay element and may also contain a TrackOffset that offsets the block timestamps.
2022-11-12 13:09:07 -06:00
auto candidate_block = TRY(parse_simple_block(streamer, m_current_cluster->timestamp(), m_segment_timestamp_scale, m_track));
if (candidate_block.track_number() == m_track.track_number())
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
block = move(candidate_block);
} else {
dbgln_if(MATROSKA_TRACE_DEBUG, " Iterator is skipping unknown element with ID {:#010x}.", element_id);
TRY_READ(streamer.read_unknown_element());
}
m_position = streamer.position();
LibVideo: Implement Matroska keyframe search for when there are no Cues This just searches sequentially through each block in a SampleIterator until it finds a block after the specified seek timestamp. Once it finds one, it will try to set the input/output iterator to the most recent keyframe. If the iterator's original position is closer to the target, however, it leaves it at that original position, allowing callers to continue decoding from that position until they reach the target timestamp.
2022-11-12 04:04:13 -06:00
if (block.has_value()) {
m_last_timestamp = block->timestamp();
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return block.release_value();
LibVideo: Implement Matroska keyframe search for when there are no Cues This just searches sequentially through each block in a SampleIterator until it finds a block after the specified seek timestamp. Once it finds one, it will try to set the input/output iterator to the most recent keyframe. If the iterator's original position is closer to the target, however, it leaves it at that original position, allowing callers to continue decoding from that position until they reach the target timestamp.
2022-11-12 04:04:13 -06:00
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
}
m_current_cluster.clear();
return DecoderError::with_description(DecoderErrorCategory::EndOfStream, "End of stream"sv);
}
LibVideo: Implement Matroska Cues for faster keyframe lookup This implements the fastest seeking mode available for tracks with cues using an array of cue points for each track. It approximates the index based on the seeking timestamp and then finds the earliest cue point before the timestamp. The approximation assumes that cues will be on a regular interval, which I don't believe is always the case, but it should at least be faster than iterating the whole set of cue points each time. Cues are stored per track, but most videos will only have cue points for the video track(s) that are present. For now, this assumes that it should only seek based on the cue points for the selected track. To seek audio in a video file, we should copy the seeked iterator over to the audio track's iterator after seeking is complete. The iterator will then skip to the next audio block.
2022-11-13 19:28:56 -06:00
DecoderErrorOr<void> SampleIterator::seek_to_cue_point(CuePoint const& cue_point)
{
// This is a private function. The position getter can return optional, but the caller should already know that this track has a position.
auto const& cue_position = cue_point.position_for_track(m_track.track_number()).release_value();
Streamer streamer { m_data };
TRY_READ(streamer.seek_to_position(cue_position.cluster_position()));
auto element_id = TRY_READ(streamer.read_variable_size_integer(false));
if (element_id != CLUSTER_ELEMENT_ID)
return DecoderError::corrupted("Cue point's cluster position didn't point to a cluster"sv);
m_current_cluster = TRY(parse_cluster(streamer, m_segment_timestamp_scale));
dbgln_if(MATROSKA_DEBUG, "SampleIterator set to cue point at timestamp {}ms", m_current_cluster->timestamp().to_milliseconds());
m_position = streamer.position() + cue_position.block_offset();
m_last_timestamp = cue_point.timestamp();
return {};
}
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
ErrorOr<ByteString> Streamer::read_string()
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
auto string_length = TRY(read_variable_size_integer());
if (remaining() < string_length)
return Error::from_string_literal("String length extends past the end of the stream");
LibVideo: Fix string reading in Matroska A string should never be longer than it's strlen according to the specification
2023-11-27 10:12:47 +01:00
auto string_data = data_as_chars();
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
auto string_value = ByteString(string_data, strnlen(string_data, string_length));
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
TRY(read_raw_octets(string_length));
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
return string_value;
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
ErrorOr<u8> Streamer::read_octet()
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
if (!has_octet()) {
dbgln_if(MATROSKA_TRACE_DEBUG, "Ran out of stream data");
return Error::from_string_literal("Stream is out of data");
}
LibVideo: Parse Matroska from ReadonlyBytes and keep the start position Keeping the entire Matroska stream available is a prerequisite to being able to stream from it and seek to cue points.
2022-11-10 16:58:53 -06:00
u8 byte = *data();
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
m_octets_read.last()++;
LibVideo: Parse Matroska from ReadonlyBytes and keep the start position Keeping the entire Matroska stream available is a prerequisite to being able to stream from it and seek to cue points.
2022-11-10 16:58:53 -06:00
m_position++;
return byte;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
ErrorOr<i16> Streamer::read_i16()
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
{
return (TRY(read_octet()) << 8) | TRY(read_octet());
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
ErrorOr<u64> Streamer::read_variable_size_integer(bool mask_length)
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
{
LibVideo/Matroska: Don't choke on files containing CRC32 elements The EBML specification allows for CRC32 elements to be placed as the first child element of a master element. However, our parsing of master elements didn't take that into account, so an error would be thrown. Instead of erroring out, the `parse_master_element()` function will now skip CRC32 elements that are found as the first child of a master element. If it is found after the first child, that will be considered an error. Void elements will also be skipped by `parse_master_element()`. Since the `parse_cluster()` function has to seek the stream back to the cluster's first child in order to allow cues' positions to be used correctly, `parse_master_element()` had to be changed to return the first element position, since the callback is not invoked for CRC32 elements. This means that the parameter used to communicate the element position to the child element parsing function is unused, so that is removed.
2023-06-24 03:21:32 -05:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Reading VINT from offset {:p}", position());
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
auto length_descriptor = TRY(read_octet());
dbgln_if(MATROSKA_TRACE_DEBUG, "Reading VINT, first byte is {:#02x}", length_descriptor);
if (length_descriptor == 0)
return Error::from_string_literal("read_variable_size_integer: Length descriptor has no terminating set bit");
size_t length = 0;
while (length < 8) {
if (((length_descriptor >> (8 - length)) & 1) == 1)
break;
length++;
}
dbgln_if(MATROSKA_TRACE_DEBUG, "Reading VINT of total length {}", length);
if (length > 8)
return Error::from_string_literal("read_variable_size_integer: Length is too large");
u64 result;
if (mask_length)
result = length_descriptor & ~(1u << (8 - length));
else
result = length_descriptor;
dbgln_if(MATROSKA_TRACE_DEBUG, "Beginning of VINT is {:#02x}", result);
for (size_t i = 1; i < length; i++) {
u8 next_octet = TRY(read_octet());
dbgln_if(MATROSKA_TRACE_DEBUG, "Read octet of {:#02x}", next_octet);
result = (result << 8u) | next_octet;
dbgln_if(MATROSKA_TRACE_DEBUG, "New result is {:#010x}", result);
}
return result;
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
ErrorOr<i64> Streamer::read_variable_size_signed_integer()
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
{
auto length_descriptor = TRY(read_octet());
if (length_descriptor == 0)
return Error::from_string_literal("read_variable_sized_signed_integer: Length descriptor has no terminating set bit");
i64 length = 0;
while (length < 8) {
if (((length_descriptor >> (8 - length)) & 1) == 1)
break;
length++;
}
if (length > 8)
return Error::from_string_literal("read_variable_size_integer: Length is too large");
i64 result = length_descriptor & ~(1u << (8 - length));
for (i64 i = 1; i < length; i++) {
u8 next_octet = TRY(read_octet());
result = (result << 8u) | next_octet;
}
result -= AK::exp2<i64>(length * 7 - 1) - 1;
return result;
}
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
ErrorOr<ReadonlyBytes> Streamer::read_raw_octets(size_t num_octets)
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
{
if (remaining() < num_octets)
return Error::from_string_literal("Tried to drop octets past the end of the stream");
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
ReadonlyBytes result = { data(), num_octets };
LibVideo: Parse Matroska from ReadonlyBytes and keep the start position Keeping the entire Matroska stream available is a prerequisite to being able to stream from it and seek to cue points.
2022-11-10 16:58:53 -06:00
m_position += num_octets;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
m_octets_read.last() += num_octets;
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
return result;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
ErrorOr<u64> Streamer::read_u64()
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
{
auto integer_length = TRY(read_variable_size_integer());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
u64 result = 0;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
for (size_t i = 0; i < integer_length; i++) {
result = (result << 8u) + TRY(read_octet());
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
return result;
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
ErrorOr<double> Streamer::read_float()
LibVideo: Parse the duration of Matroska files
2022-10-29 17:01:01 -05:00
{
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
auto length = TRY(read_variable_size_integer());
LibVideo: Parse the duration of Matroska files
2022-10-29 17:01:01 -05:00
if (length != 4u && length != 8u)
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
return Error::from_string_literal("Float size must be 4 or 8 bytes");
LibVideo: Parse the duration of Matroska files
2022-10-29 17:01:01 -05:00
union {
u64 value;
float float_value;
double double_value;
} read_data;
read_data.value = 0;
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
for (size_t i = 0; i < length; i++) {
read_data.value = (read_data.value << 8u) + TRY(read_octet());
LibVideo: Parse the duration of Matroska files
2022-10-29 17:01:01 -05:00
}
if (length == 4u)
return read_data.float_value;
return read_data.double_value;
}
LibVideo: Make Matroska element parsing functions static Making these functions static makes it easier to implement lazy-loading since the parsing functions can now be called at any time. The functions were reorganized because they were not defined in the order they are called. However, instead of moving every function to that order, I've declared some but defined them further into the file, which allows the next commit's diff to be more readable.
2022-11-11 19:09:53 -06:00
ErrorOr<void> Streamer::read_unknown_element()
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
{
LibVideo: Propagate decoder errors in the Matroska Reader Matroska::Reader functions now return DecoderErrorOr instead of values being declared Optional. Useful errors can be handled by the users of the parser, similarly to the VP9 decoder. A lot of the error checking in the reader is a lot cleaner thanks to this change, since all reads can be range checked in Streamer::read_octet() now. Most functions for the Streamer class are now also out-of-line in Reader.cpp now instead of residing in the header.
2022-11-09 23:38:50 -06:00
auto element_length = TRY(read_variable_size_integer());
LibVideo: Read Matroska lazily so that large files can start quickly The Demuxer class was changed to return errors for more functions so that all of the underlying reading can be done lazily. Other than that, the demuxer interface is unchanged, and only the underlying reader was modified. The MatroskaDocument class is no more, and MatroskaReader's getter functions replace it. Every MatroskaReader getter beyond the Segment element's position is parsed lazily from the file as needed. This means that all getter functions can return DecoderErrors which must be handled by callers.
2022-11-11 17:14:27 -06:00
dbgln_if(MATROSKA_TRACE_DEBUG, "Skipping unknown element of size {}.", element_length);
TRY(read_raw_octets(element_length));
return {};
}
ErrorOr<void> Streamer::seek_to_position(size_t position)
{
if (position >= m_data.size())
return Error::from_string_literal("Attempted to seek past the end of the stream");
m_position = position;
return {};
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 16:06:55 -04:00
}
}
Reference in a new issue Copy permalink