beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-30 00:31:14 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

LibVideo: Parse Matroska from ReadonlyBytes and keep the start position

Browse source 
Keeping the entire Matroska stream available is a prerequisite to being
able to stream from it and seek to cue points.
This commit is contained in:
Zaggy1024 2022-11-10 16:58:53 -06:00 committed by Andreas Kling
parent 2dfd236dcd
commit be9de58932
Notes: sideshowbarker 2024-07-17 05:13:53 +09:00 
Author: https://github.com/Zaggy1024
Commit: https://github.com/SerenityOS/serenity/commit/be9de58932
Pull-request: https://github.com/SerenityOS/serenity/pull/16063
3 changed files with 21 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.cpp
View file

@ -15,7 +15,7 @@ DecoderErrorOr<NonnullOwnPtr<MatroskaDemuxer>> MatroskaDemuxer::from_file(String
DecoderErrorOr<NonnullOwnPtr<MatroskaDemuxer>> MatroskaDemuxer::from_data(ReadonlyBytes data)
{
return make<MatroskaDemuxer>(TRY(Reader::parse_matroska_from_data(data.data(), data.size())));
return make<MatroskaDemuxer>(TRY(Reader::parse_matroska_from_data(data)));
}
Vector<Track> MatroskaDemuxer::get_tracks_for_type(TrackType type)

16
Userland/Libraries/LibVideo/Containers/Matroska/Reader.cpp
View file

@ -58,12 +58,12 @@ constexpr u32 TIMESTAMP_ID = 0xE7;
DecoderErrorOr<NonnullOwnPtr<MatroskaDocument>> Reader::parse_matroska_from_file(StringView path)
{
auto mapped_file = DECODER_TRY(DecoderErrorCategory::IO, Core::MappedFile::map(path));
return parse_matroska_from_data((u8*)mapped_file->data(), mapped_file->size());
return parse_matroska_from_data(mapped_file->bytes());
}
DecoderErrorOr<NonnullOwnPtr<MatroskaDocument>> Reader::parse_matroska_from_data(u8 const* data, size_t size)
DecoderErrorOr<NonnullOwnPtr<MatroskaDocument>> Reader::parse_matroska_from_data(ReadonlyBytes data)
{
Reader reader(data, size);
Reader reader(data);
return reader.parse();
}
@ -426,9 +426,10 @@ ErrorOr<u8> Reader::Streamer::read_octet()
dbgln_if(MATROSKA_TRACE_DEBUG, "Ran out of stream data");
return Error::from_string_literal("Stream is out of data");
}
m_size_remaining--;
u8 byte = *data();
m_octets_read.last()++;
return *(m_data_ptr++);
m_position++;
return byte;
}
ErrorOr<i16> Reader::Streamer::read_i16()
@ -438,7 +439,7 @@ ErrorOr<i16> Reader::Streamer::read_i16()
ErrorOr<u64> Reader::Streamer::read_variable_size_integer(bool mask_length)
{
dbgln_if(MATROSKA_TRACE_DEBUG, "Reading from offset {:p}", m_data_ptr);
dbgln_if(MATROSKA_TRACE_DEBUG, "Reading from offset {:p}", data());
auto length_descriptor = TRY(read_octet());
dbgln_if(MATROSKA_TRACE_DEBUG, "Reading VINT, first byte is {:#02x}", length_descriptor);
if (length_descriptor == 0)
@ -495,9 +496,8 @@ ErrorOr<void> Reader::Streamer::drop_octets(size_t num_octets)
{
if (remaining() < num_octets)
return Error::from_string_literal("Tried to drop octets past the end of the stream");
m_size_remaining -= num_octets;
m_position += num_octets;
m_octets_read.last() += num_octets;
m_data_ptr += num_octets;
return {};
}

26
Userland/Libraries/LibVideo/Containers/Matroska/Reader.h
View file

@ -20,28 +20,27 @@ namespace Video::Matroska {
class Reader {
public:
Reader(u8 const* data, size_t size)
: m_streamer(data, size)
Reader(ReadonlyBytes data)
: m_streamer(data)
{
}
static DecoderErrorOr<NonnullOwnPtr<MatroskaDocument>> parse_matroska_from_file(StringView path);
static DecoderErrorOr<NonnullOwnPtr<MatroskaDocument>> parse_matroska_from_data(u8 const*, size_t);
static DecoderErrorOr<NonnullOwnPtr<MatroskaDocument>> parse_matroska_from_data(ReadonlyBytes data);
DecoderErrorOr<NonnullOwnPtr<MatroskaDocument>> parse();
private:
class Streamer {
public:
Streamer(u8 const* data, size_t size)
: m_data_ptr(data)
, m_size_remaining(size)
Streamer(ReadonlyBytes data)
: m_data(data)
{
}
u8 const* data() { return m_data_ptr; }
u8 const* data() { return m_data.data() + m_position; }
char const* data_as_chars() { return reinterpret_cast<char const*>(m_data_ptr); }
char const* data_as_chars() { return reinterpret_cast<char const*>(data()); }
size_t octets_read() { return m_octets_read.last(); }
@ -70,15 +69,14 @@ private:
ErrorOr<void> drop_octets(size_t num_octets);
bool at_end() const { return m_size_remaining == 0; }
bool has_octet() const { return m_size_remaining >= 1; }
bool at_end() const { return remaining() == 0; }
bool has_octet() const { return remaining() >= 1; }
size_t remaining() const { return m_size_remaining; }
void set_remaining(size_t remaining) { m_size_remaining = remaining; }
size_t remaining() const { return m_data.size() - m_position; }
private:
u8 const* m_data_ptr { nullptr };
size_t m_size_remaining { 0 };
ReadonlyBytes m_data;
size_t m_position { 0 };
Vector<size_t> m_octets_read { 0 };
};