Ladybird/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-06-11 18:20:43 +09:00
Code Activity

LibVideo: Handle corrupted video errors without spamming dialogs

Browse source 
No longer will the video player explode with error dialogs that then
lock the user out of closing them.

To avoid issues where the playback state becomes invalid when an error
occurs, I've made all decoder errors pass through the frame queue.
This way, when a video is corrupted, there should be no chance that the
playback state becomes invalid due to setting the state to Corrupted
in the event handler while a presentation event is still pending.
Or at least I think that was what caused some issues I was seeing :^)

This system should be a lot more robust if any future errors need to be
handled.
This commit is contained in:
Zaggy1024 2022-11-09 06:52:37 -06:00 • committed by Ali Mohammad Pur
parent a2a4ad3b9d
commit 18a6a1dd10
Notes: sideshowbarker 2024-07-17 05:09:48 +09:00
4 changed files with 98 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Userland/Applications/VideoPlayer/VideoPlayerWidget.cpp
View file

@ -127,7 +127,7 @@ void VideoPlayerWidget::toggle_pause()
resume_playback();
}
void VideoPlayerWidget::on_decoding_error(Video::DecoderError error)
void VideoPlayerWidget::on_decoding_error(Video::DecoderError const& error)
{
StringView text_format;

2
Userland/Applications/VideoPlayer/VideoPlayerWidget.h
View file

@ -35,7 +35,7 @@ private:
VideoPlayerWidget(GUI::Window&);
void update_play_pause_icon();
void on_decoding_error(Video::DecoderError);
void on_decoding_error(Video::DecoderError const&);
void display_next_frame();
void cycle_sizing_modes();

81
Userland/Libraries/LibVideo/PlaybackManager.cpp
View file

@ -14,20 +14,6 @@
namespace Video {
// We post DecoderErrors to the event queue to be handled, since some will occur off the main thread.
#define TRY_OR_POST_ERROR_AND_RETURN(expression, return_value) \
({ \
auto _temporary_result = ((expression)); \
if (_temporary_result.is_error()) { \
dbgln("Playback error encountered: {}", _temporary_result.error().string_literal()); \
m_main_loop.post_event(*this, make<DecoderErrorEvent>(_temporary_result.release_error())); \
return return_value; \
} \
_temporary_result.release_value(); \
})
#define TRY_OR_POST_ERROR(expression) TRY_OR_POST_ERROR_AND_RETURN(expression, )
DecoderErrorOr<NonnullRefPtr<PlaybackManager>> PlaybackManager::from_file(Object* event_handler, StringView filename)
{
NonnullOwnPtr<Demuxer> demuxer = TRY(MatroskaDemuxer::from_file(filename));
@ -69,7 +55,7 @@ void PlaybackManager::set_playback_status(PlaybackStatus status)
dbgln_if(PLAYBACK_MANAGER_DEBUG, "Set playback status from {} to {}", playback_status_to_string(old_status), playback_status_to_string(m_status));
if (status == PlaybackStatus::Playing) {
if (old_status == PlaybackStatus::Stopped) {
if (old_status == PlaybackStatus::Stopped || old_status == PlaybackStatus::Corrupted) {
restart_playback();
m_frame_queue->clear();
m_skipped_frames = 0;
@ -91,6 +77,7 @@ void PlaybackManager::event(Core::Event& event)
if (event.type() == DecoderErrorOccurred) {
auto& error_event = static_cast<DecoderErrorEvent&>(event);
VERIFY(error_event.error().category() != DecoderErrorCategory::EndOfStream);
set_playback_status(PlaybackStatus::Corrupted);
}
// Allow events to bubble up in all cases.
@ -114,7 +101,7 @@ bool PlaybackManager::prepare_next_frame()
if (m_frame_queue->is_empty())
return false;
auto frame_item = m_frame_queue->dequeue();
m_next_frame.emplace(frame_item);
m_next_frame.emplace(move(frame_item));
m_decode_timer->start();
return true;
}
@ -131,6 +118,20 @@ Time PlaybackManager::duration()
return m_demuxer->duration();
}
void PlaybackManager::on_decoder_error(DecoderError error)
{
dbgln("Playback error encountered: {}", error.string_literal());
switch (error.category()) {
case DecoderErrorCategory::EndOfStream:
set_playback_status(PlaybackStatus::Stopped);
break;
default:
set_playback_status(PlaybackStatus::Corrupted);
m_main_loop.post_event(*this, make<DecoderErrorEvent>(move(error)));
break;
}
}
void PlaybackManager::update_presented_frame()
{
bool out_of_queued_frames = false;
@ -141,18 +142,18 @@ void PlaybackManager::update_presented_frame()
if (out_of_queued_frames)
break;
VERIFY(m_next_frame.has_value());
if (m_next_frame->timestamp > current_playback_time() || m_next_frame->is_eos_marker())
if (m_next_frame->is_error() || m_next_frame->timestamp() > current_playback_time())
break;
if (frame_item_to_display.has_value()) {
dbgln_if(PLAYBACK_MANAGER_DEBUG, "At {}ms: Dropped frame with timestamp {}ms for the next at {}ms", current_playback_time().to_milliseconds(), frame_item_to_display->timestamp.to_milliseconds(), m_next_frame->timestamp.to_milliseconds());
dbgln_if(PLAYBACK_MANAGER_DEBUG, "At {}ms: Dropped {} in favor of {}", current_playback_time().to_milliseconds(), frame_item_to_display->debug_string(), m_next_frame->debug_string());
m_skipped_frames++;
}
frame_item_to_display = m_next_frame.release_value();
}
if (!out_of_queued_frames && frame_item_to_display.has_value()) {
m_main_loop.post_event(*this, make<VideoFramePresentEvent>(frame_item_to_display->bitmap));
m_main_loop.post_event(*this, make<VideoFramePresentEvent>(frame_item_to_display->bitmap()));
m_last_present_in_media_time = current_playback_time();
m_last_present_in_real_time = Time::now_monotonic();
frame_item_to_display.clear();
@ -161,20 +162,20 @@ void PlaybackManager::update_presented_frame()
if (frame_item_to_display.has_value()) {
VERIFY(!m_next_frame.has_value());
m_next_frame = frame_item_to_display;
dbgln_if(PLAYBACK_MANAGER_DEBUG, "Set next frame back to dequeued item at timestamp {}ms", m_next_frame->timestamp.to_milliseconds());
dbgln_if(PLAYBACK_MANAGER_DEBUG, "Set next frame back to dequeued item {}", m_next_frame->debug_string());
}
if (!is_playing())
return;
if (!out_of_queued_frames) {
if (m_next_frame->is_eos_marker()) {
set_playback_status(PlaybackStatus::Stopped);
if (m_next_frame->is_error()) {
on_decoder_error(m_next_frame->release_error());
m_next_frame.clear();
return;
}
auto frame_time_ms = (m_next_frame.value().timestamp - current_playback_time()).to_milliseconds();
auto frame_time_ms = (m_next_frame->timestamp() - current_playback_time()).to_milliseconds();
VERIFY(frame_time_ms <= NumericLimits<int>::max());
dbgln_if(PLAYBACK_MANAGER_DEBUG, "Time until next frame is {}ms", frame_time_ms);
m_present_timer->start(max(static_cast<int>(frame_time_ms), 0));
@ -189,7 +190,9 @@ void PlaybackManager::restart_playback()
{
m_last_present_in_media_time = Time::zero();
m_last_present_in_real_time = Time::zero();
TRY_OR_POST_ERROR(m_demuxer->seek_to_most_recent_keyframe(m_selected_video_track, 0));
auto result = m_demuxer->seek_to_most_recent_keyframe(m_selected_video_track, 0);
if (result.is_error())
on_decoder_error(result.release_error());
}
bool PlaybackManager::decode_and_queue_one_sample()
@ -200,26 +203,28 @@ bool PlaybackManager::decode_and_queue_one_sample()
auto start_time = Time::now_monotonic();
#endif
auto frame_sample_result = m_demuxer->get_next_video_sample_for_track(m_selected_video_track);
if (frame_sample_result.is_error()) {
if (frame_sample_result.error().category() == DecoderErrorCategory::EndOfStream) {
m_frame_queue->enqueue(FrameQueueItem::eos_marker());
return false;
}
m_main_loop.post_event(*this, make<DecoderErrorEvent>(frame_sample_result.release_error()));
return false;
}
auto frame_sample = frame_sample_result.release_value();
#define TRY_OR_ENQUEUE_ERROR(expression) \
({ \
auto _temporary_result = ((expression)); \
if (_temporary_result.is_error()) { \
dbgln("Enqueued decoder error: {}", _temporary_result.error().string_literal()); \
m_frame_queue->enqueue(FrameQueueItem::error_marker(_temporary_result.release_error())); \
return false; \
} \
_temporary_result.release_value(); \
})
TRY_OR_POST_ERROR_AND_RETURN(m_decoder->receive_sample(frame_sample->data()), false);
auto decoded_frame = TRY_OR_POST_ERROR_AND_RETURN(m_decoder->get_decoded_frame(), false);
auto frame_sample = TRY_OR_ENQUEUE_ERROR(m_demuxer->get_next_video_sample_for_track(m_selected_video_track));
TRY_OR_ENQUEUE_ERROR(m_decoder->receive_sample(frame_sample->data()));
auto decoded_frame = TRY_OR_ENQUEUE_ERROR(m_decoder->get_decoded_frame());
auto& cicp = decoded_frame->cicp();
cicp.adopt_specified_values(frame_sample->container_cicp());
cicp.default_code_points_if_unspecified({ Video::ColorPrimaries::BT709, Video::TransferCharacteristics::BT709, Video::MatrixCoefficients::BT709, Video::ColorRange::Studio });
auto bitmap = TRY_OR_POST_ERROR_AND_RETURN(decoded_frame->to_bitmap(), false);
m_frame_queue->enqueue(FrameQueueItem { bitmap, frame_sample->timestamp() });
auto bitmap = TRY_OR_ENQUEUE_ERROR(decoded_frame->to_bitmap());
m_frame_queue->enqueue(FrameQueueItem::frame(bitmap, frame_sample->timestamp()));
#if PLAYBACK_MANAGER_DEBUG
auto end_time = Time::now_monotonic();

59
Userland/Libraries/LibVideo/PlaybackManager.h
View file

@ -30,18 +30,62 @@ enum class PlaybackStatus {
Buffering,
Seeking,
Stopped,
Corrupted,
};
struct FrameQueueItem {
static FrameQueueItem eos_marker()
enum class Type {
Frame,
Error,
};
static FrameQueueItem frame(RefPtr<Gfx::Bitmap> bitmap, Time timestamp)
{
return { nullptr, Time::max() };
return FrameQueueItem(move(bitmap), timestamp);
}
RefPtr<Gfx::Bitmap> bitmap;
Time timestamp;
static FrameQueueItem error_marker(DecoderError&& error)
{
return FrameQueueItem(move(error));
}
bool is_eos_marker() const { return !bitmap; }
bool is_frame() const { return m_data.has<FrameData>(); }
RefPtr<Gfx::Bitmap> bitmap() const { return m_data.get<FrameData>().bitmap; }
Time timestamp() const { return m_data.get<FrameData>().timestamp; }
bool is_error() const { return m_data.has<DecoderError>(); }
DecoderError const& error() const { return m_data.get<DecoderError>(); }
DecoderError release_error()
{
auto error = move(m_data.get<DecoderError>());
m_data.set(Empty());
return error;
}
String debug_string() const
{
if (is_error())
return error().string_literal();
return String::formatted("frame at {}ms", timestamp().to_milliseconds());
}
private:
struct FrameData {
RefPtr<Gfx::Bitmap> bitmap;
Time timestamp;
};
FrameQueueItem(RefPtr<Gfx::Bitmap> bitmap, Time timestamp)
: m_data(FrameData { move(bitmap), timestamp })
{
}
FrameQueueItem(DecoderError&& error)
: m_data(move(error))
{
}
Variant<Empty, FrameData, DecoderError> m_data;
};
static constexpr size_t FRAME_BUFFER_COUNT = 4;
@ -67,6 +111,7 @@ public:
u64 number_of_skipped_frames() const { return m_skipped_frames; }
void event(Core::Event& event) override;
void on_decoder_error(DecoderError error);
Time current_playback_time();
Time duration();
@ -119,7 +164,7 @@ public:
}
virtual ~DecoderErrorEvent() = default;
DecoderError error() { return m_error; }
DecoderError const& error() { return m_error; }
private:
DecoderError m_error;
@ -173,6 +218,8 @@ inline StringView playback_status_to_string(PlaybackStatus status)
return "Seeking"sv;
case PlaybackStatus::Stopped:
return "Stopped"sv;
case PlaybackStatus::Corrupted:
return "Corrupted"sv;
}
return "Unknown"sv;
};