723 lines
27 KiB
C++
723 lines
27 KiB
C++
#include <flutter_linux/flutter_linux.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
|
|
#include <atomic>
|
|
#include <cerrno>
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <csignal>
|
|
#include <cstdlib>
|
|
#include <exception>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <stdexcept>
|
|
#include <thread>
|
|
#include <utility>
|
|
|
|
#include "mpv_player.h"
|
|
#include "mpv_texture.h"
|
|
|
|
struct LifetimeTextureRegistrar {
|
|
GObject parent_instance;
|
|
FlTexture* texture;
|
|
};
|
|
|
|
struct LifetimeTextureRegistrarClass {
|
|
GObjectClass parent_class;
|
|
};
|
|
|
|
static void LifetimeTextureRegistrarInterfaceInit(FlTextureRegistrarInterface* interface);
|
|
static void LifetimeTextureRegistrarDispose(GObject* object);
|
|
static void lifetime_texture_registrar_class_init(LifetimeTextureRegistrarClass* klass);
|
|
static void lifetime_texture_registrar_init(LifetimeTextureRegistrar* self);
|
|
|
|
G_DEFINE_TYPE_WITH_CODE(
|
|
LifetimeTextureRegistrar, lifetime_texture_registrar, G_TYPE_OBJECT,
|
|
G_IMPLEMENT_INTERFACE(fl_texture_registrar_get_type(), LifetimeTextureRegistrarInterfaceInit))
|
|
|
|
static gboolean LifetimeTextureRegistrarRegister(FlTextureRegistrar* registrar, FlTexture* texture) {
|
|
auto* self = reinterpret_cast<LifetimeTextureRegistrar*>(registrar);
|
|
if (self->texture) return FALSE;
|
|
self->texture = FL_TEXTURE(g_object_ref(texture));
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean LifetimeTextureRegistrarUnregister(FlTextureRegistrar* registrar, FlTexture* texture) {
|
|
auto* self = reinterpret_cast<LifetimeTextureRegistrar*>(registrar);
|
|
if (self->texture != texture) return FALSE;
|
|
g_clear_object(&self->texture);
|
|
return TRUE;
|
|
}
|
|
|
|
static void LifetimeTextureRegistrarInterfaceInit(FlTextureRegistrarInterface* interface) {
|
|
interface->register_texture = LifetimeTextureRegistrarRegister;
|
|
interface->unregister_texture = LifetimeTextureRegistrarUnregister;
|
|
}
|
|
|
|
static void LifetimeTextureRegistrarDispose(GObject* object) {
|
|
auto* self = reinterpret_cast<LifetimeTextureRegistrar*>(object);
|
|
g_clear_object(&self->texture);
|
|
G_OBJECT_CLASS(lifetime_texture_registrar_parent_class)->dispose(object);
|
|
}
|
|
|
|
static void lifetime_texture_registrar_class_init(LifetimeTextureRegistrarClass* klass) {
|
|
G_OBJECT_CLASS(klass)->dispose = LifetimeTextureRegistrarDispose;
|
|
}
|
|
|
|
static void lifetime_texture_registrar_init(LifetimeTextureRegistrar* self) { self->texture = nullptr; }
|
|
|
|
namespace mpv {
|
|
|
|
class MpvPlayerLifecycleTestPeer {
|
|
public:
|
|
static std::shared_ptr<MpvPlayer::CallbackContext> RetainContext(MpvPlayer& player) {
|
|
return player.callback_context_;
|
|
}
|
|
|
|
static void Wakeup(const std::shared_ptr<MpvPlayer::CallbackContext>& context) {
|
|
MpvPlayer::OnMpvWakeup(context.get());
|
|
}
|
|
|
|
static void RenderUpdate(const std::shared_ptr<MpvPlayer::CallbackContext>& context) {
|
|
MpvPlayer::OnMpvRenderUpdate(context.get());
|
|
}
|
|
|
|
static void WaitUntilDetached(const std::shared_ptr<MpvPlayer::CallbackContext>& context) {
|
|
context->WaitUntilDetached();
|
|
}
|
|
static void ScheduleRecovery(MpvPlayer& player) { player.ScheduleRecoverySource(); }
|
|
|
|
static void RegisterPendingPropertyWrite(MpvPlayer& player, MpvPlayer::StatusCallback callback) {
|
|
player.pending_requests_.RegisterStatus(std::move(callback));
|
|
}
|
|
|
|
static int PendingSourceCount(MpvPlayer& player) {
|
|
std::lock_guard<std::mutex> lock(player.source_mutex_);
|
|
return (player.wakeup_source_id_ != 0 ? 1 : 0) + (player.redraw_source_id_ != 0 ? 1 : 0) +
|
|
(player.recovery_source_id_ != 0 ? 1 : 0);
|
|
}
|
|
static FlValue* ConvertNode(MpvPlayer& player, mpv_node* node) { return player.NodeToFlValue(node); }
|
|
static FlValue* ConvertNodeWithBudget(
|
|
MpvPlayer& player, mpv_node* node, size_t remaining_entries, size_t remaining_bytes) {
|
|
MpvPlayer::NodeConversionBudget budget{remaining_entries, remaining_bytes};
|
|
return player.NodeToFlValue(node, 0, &budget);
|
|
}
|
|
static void RegisterObservedNode(MpvPlayer& player, const std::string& name, int id) {
|
|
player.observed_properties_.Register(name, "node", id);
|
|
}
|
|
static void HandleEvent(MpvPlayer& player, mpv_event* event) { player.HandleMpvEvent(event); }
|
|
|
|
static void HoldLease(
|
|
const std::shared_ptr<MpvPlayer::CallbackContext>& context, std::mutex& mutex, std::condition_variable& condition,
|
|
bool& entered, bool& release) {
|
|
auto lease = context->Acquire();
|
|
{
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
entered = static_cast<bool>(lease);
|
|
}
|
|
condition.notify_all();
|
|
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
condition.wait(lock, [&release]() { return release; });
|
|
}
|
|
};
|
|
|
|
namespace {
|
|
|
|
void Check(bool condition, const char* message) {
|
|
if (!condition) throw std::runtime_error(message);
|
|
}
|
|
|
|
void Drain(GMainContext* context) {
|
|
while (g_main_context_iteration(context, FALSE)) {
|
|
}
|
|
}
|
|
|
|
bool WriteByte(int descriptor, char value) {
|
|
for (;;) {
|
|
const ssize_t written = write(descriptor, &value, 1);
|
|
if (written == 1) return true;
|
|
if (written < 0 && errno == EINTR) continue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ReadByte(int descriptor, char expected) {
|
|
char value = '\0';
|
|
for (;;) {
|
|
const ssize_t received = read(descriptor, &value, 1);
|
|
if (received == 1) return value == expected;
|
|
if (received < 0 && errno == EINTR) continue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[[noreturn]] void ExitBlockedTeardownChild(int status) { _exit(status); }
|
|
|
|
int RunBlockedTeardownShutdownChild(int progress_read, int progress_write, int release_read) {
|
|
auto* const completed_handle = reinterpret_cast<mpv_handle*>(0x11);
|
|
auto* const blocked_render = reinterpret_cast<mpv_render_context*>(0x12);
|
|
auto const blocked_display = reinterpret_cast<EGLDisplay>(0x13);
|
|
auto const blocked_context = reinterpret_cast<EGLContext>(0x14);
|
|
|
|
NativeRenderTeardownOperations operations{
|
|
[](EGLDisplay, EGLContext) { return true; },
|
|
[](EGLDisplay) { return true; },
|
|
[](EGLDisplay, EGLContext) { return true; },
|
|
[progress_write, release_read, blocked_render](mpv_render_context* render) {
|
|
if (render != blocked_render || !WriteByte(progress_write, 'B')) ExitBlockedTeardownChild(121);
|
|
char release = '\0';
|
|
for (;;) {
|
|
const ssize_t received = read(release_read, &release, 1);
|
|
if (received == 1) break;
|
|
if (received < 0 && errno == EINTR) continue;
|
|
ExitBlockedTeardownChild(122);
|
|
}
|
|
},
|
|
[progress_write, completed_handle](mpv_handle* handle) {
|
|
if (handle != completed_handle || !WriteByte(progress_write, 'R')) ExitBlockedTeardownChild(123);
|
|
},
|
|
};
|
|
ConfigureNativeRenderTeardownQueueForTesting(std::move(operations));
|
|
|
|
NativeRenderTeardownBatch completed_batch;
|
|
completed_batch.handle = completed_handle;
|
|
EnqueueNativeRenderTeardownForTesting(std::move(completed_batch));
|
|
if (!ReadByte(progress_read, 'R')) return 124;
|
|
|
|
NativeRenderTeardownBatch blocked_batch;
|
|
blocked_batch.resources.push_back({blocked_render, blocked_display, blocked_context});
|
|
EnqueueNativeRenderTeardownForTesting(std::move(blocked_batch));
|
|
if (!ReadByte(progress_read, 'B')) return 125;
|
|
|
|
// Returning through std::exit below deliberately begins normal static
|
|
// shutdown while the queue worker remains blocked in free_render.
|
|
return 0;
|
|
}
|
|
|
|
void TestProcessShutdownDoesNotJoinBlockedNativeTeardown() {
|
|
int progress_pipe[2] = {-1, -1};
|
|
int release_pipe[2] = {-1, -1};
|
|
Check(pipe(progress_pipe) == 0, "could not create teardown progress barrier");
|
|
if (pipe(release_pipe) != 0) {
|
|
close(progress_pipe[0]);
|
|
close(progress_pipe[1]);
|
|
Check(false, "could not create teardown release barrier");
|
|
}
|
|
|
|
const pid_t child = fork();
|
|
if (child == 0) {
|
|
close(release_pipe[1]);
|
|
const int status = RunBlockedTeardownShutdownChild(progress_pipe[0], progress_pipe[1], release_pipe[0]);
|
|
std::exit(status);
|
|
}
|
|
if (child < 0) {
|
|
close(progress_pipe[0]);
|
|
close(progress_pipe[1]);
|
|
close(release_pipe[0]);
|
|
close(release_pipe[1]);
|
|
Check(false, "could not create teardown shutdown subprocess");
|
|
}
|
|
|
|
close(progress_pipe[0]);
|
|
close(progress_pipe[1]);
|
|
close(release_pipe[0]);
|
|
|
|
std::mutex wait_mutex;
|
|
std::condition_variable wait_condition;
|
|
bool wait_finished = false;
|
|
pid_t wait_result = -1;
|
|
int child_status = 0;
|
|
std::thread waiter([&]() {
|
|
pid_t result;
|
|
do {
|
|
result = waitpid(child, &child_status, 0);
|
|
} while (result < 0 && errno == EINTR);
|
|
{
|
|
std::lock_guard<std::mutex> lock(wait_mutex);
|
|
wait_result = result;
|
|
wait_finished = true;
|
|
}
|
|
wait_condition.notify_one();
|
|
});
|
|
|
|
bool exited_before_deadline = false;
|
|
{
|
|
std::unique_lock<std::mutex> lock(wait_mutex);
|
|
exited_before_deadline = wait_condition.wait_for(lock, std::chrono::seconds(2), [&]() { return wait_finished; });
|
|
}
|
|
if (!exited_before_deadline) kill(child, SIGKILL);
|
|
close(release_pipe[1]);
|
|
waiter.join();
|
|
|
|
Check(exited_before_deadline, "normal process shutdown joined a deliberately blocked native teardown");
|
|
Check(wait_result == child, "could not collect teardown shutdown subprocess");
|
|
Check(WIFEXITED(child_status), "teardown shutdown subprocess terminated abnormally");
|
|
Check(WEXITSTATUS(child_status) == 0, "teardown shutdown subprocess did not reach normal static shutdown");
|
|
}
|
|
|
|
struct TextureLifetimeState {
|
|
std::mutex mutex;
|
|
std::condition_variable condition;
|
|
bool callback_entered = false;
|
|
bool release_callback = false;
|
|
std::atomic<bool> callback_finalized{false};
|
|
bool finalized_during_callback = false;
|
|
};
|
|
|
|
void BlockingTextureReadyCallback(gboolean, const gchar*, gpointer user_data) {
|
|
auto* state = static_cast<TextureLifetimeState*>(user_data);
|
|
{
|
|
std::lock_guard<std::mutex> lock(state->mutex);
|
|
state->callback_entered = true;
|
|
}
|
|
state->condition.notify_all();
|
|
|
|
std::unique_lock<std::mutex> lock(state->mutex);
|
|
state->condition.wait(lock, [state]() { return state->release_callback; });
|
|
state->finalized_during_callback = state->callback_finalized.load();
|
|
}
|
|
|
|
void TextureReadyCallbackFinalized(gpointer user_data) {
|
|
static_cast<TextureLifetimeState*>(user_data)->callback_finalized = true;
|
|
}
|
|
|
|
void TestPopulateRetainsTextureWhileBootstrapCallbackRuns() {
|
|
auto* registrar = FL_TEXTURE_REGISTRAR(g_object_new(lifetime_texture_registrar_get_type(), nullptr));
|
|
TextureLifetimeState state;
|
|
MpvTexture* texture = mpv_texture_new(nullptr, registrar, nullptr);
|
|
mpv_texture_set_ready_callback(texture, BlockingTextureReadyCallback, &state, TextureReadyCallbackFinalized);
|
|
Check(
|
|
fl_texture_registrar_register_texture(registrar, FL_TEXTURE(texture)),
|
|
"the lifetime fixture must retain the registered texture");
|
|
|
|
gboolean populate_result = TRUE;
|
|
GError* populate_error = nullptr;
|
|
std::thread raster_thread([&]() {
|
|
uint32_t target = 0;
|
|
uint32_t name = 0;
|
|
uint32_t width = 0;
|
|
uint32_t height = 0;
|
|
auto* texture_class = FL_TEXTURE_GL_GET_CLASS(texture);
|
|
populate_result = texture_class->populate(FL_TEXTURE_GL(texture), &target, &name, &width, &height, &populate_error);
|
|
});
|
|
|
|
{
|
|
std::unique_lock<std::mutex> lock(state.mutex);
|
|
state.condition.wait(lock, [&state]() { return state.callback_entered; });
|
|
}
|
|
|
|
// Match plugin teardown while populate is between releasing its mutex and
|
|
// returning from the ready callback. Unregister drops the registrar's
|
|
// reference before dispose drops the plugin's reference.
|
|
Check(
|
|
fl_texture_registrar_unregister_texture(registrar, FL_TEXTURE(texture)),
|
|
"the lifetime fixture must unregister the texture");
|
|
mpv_texture_dispose(texture);
|
|
g_object_unref(texture);
|
|
const bool finalized_before_populate_released = state.callback_finalized.load();
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(state.mutex);
|
|
state.release_callback = true;
|
|
}
|
|
state.condition.notify_all();
|
|
raster_thread.join();
|
|
|
|
Check(
|
|
!finalized_before_populate_released,
|
|
"platform disposal finalized the texture while its populate callback was still running");
|
|
Check(
|
|
!state.finalized_during_callback,
|
|
"the ready callback was finalized before populate released its retained texture reference");
|
|
Check(state.callback_finalized.load(), "the texture callback was not finalized after populate returned");
|
|
Check(!populate_result, "a populate without a player must fail");
|
|
Check(populate_error != nullptr, "failed populate must report an error");
|
|
g_clear_error(&populate_error);
|
|
g_object_unref(registrar);
|
|
}
|
|
|
|
void TestNodeConversionRejectsMalformedPayloads() {
|
|
MpvPlayer player;
|
|
|
|
mpv_node missing_list{};
|
|
missing_list.format = MPV_FORMAT_NODE_ARRAY;
|
|
missing_list.u.list = nullptr;
|
|
FlValue* result = MpvPlayerLifecycleTestPeer::ConvertNode(player, &missing_list);
|
|
Check(fl_value_get_type(result) == FL_VALUE_TYPE_NULL, "a node array without storage must decode as null");
|
|
fl_value_unref(result);
|
|
|
|
mpv_node value{};
|
|
value.format = MPV_FORMAT_INT64;
|
|
value.u.int64 = 1;
|
|
char* missing_key = nullptr;
|
|
mpv_node_list malformed_map{1, &value, &missing_key};
|
|
mpv_node map{};
|
|
map.format = MPV_FORMAT_NODE_MAP;
|
|
map.u.list = &malformed_map;
|
|
result = MpvPlayerLifecycleTestPeer::ConvertNode(player, &map);
|
|
Check(fl_value_get_type(result) == FL_VALUE_TYPE_NULL, "a node map with a null key must decode as null");
|
|
fl_value_unref(result);
|
|
|
|
char invalid_utf8[] = {'a', static_cast<char>(0xFF), 'b', '\0'};
|
|
mpv_node text{};
|
|
text.format = MPV_FORMAT_STRING;
|
|
text.u.string = invalid_utf8;
|
|
result = MpvPlayerLifecycleTestPeer::ConvertNode(player, &text);
|
|
Check(
|
|
std::string(fl_value_get_string(result)) ==
|
|
"a\xEF\xBF\xBD"
|
|
"b",
|
|
"invalid UTF-8 must be replaced before entering the Flutter codec");
|
|
fl_value_unref(result);
|
|
|
|
char oversized_text[] = "bounded";
|
|
text.u.string = oversized_text;
|
|
result =
|
|
MpvPlayerLifecycleTestPeer::ConvertNodeWithBudget(player, &text, /*remaining_entries=*/1, /*remaining_bytes=*/6);
|
|
Check(fl_value_get_type(result) == FL_VALUE_TYPE_NULL, "a node string beyond the byte budget must decode as null");
|
|
fl_value_unref(result);
|
|
}
|
|
|
|
void TestNullNodePropertyPayloadDecodesAsNull() {
|
|
MpvPlayer player;
|
|
MpvPlayerLifecycleTestPeer::RegisterObservedNode(player, "track-list", 42);
|
|
bool delivered = false;
|
|
player.SetEventCallback([&delivered](FlValue* event) {
|
|
Check(fl_value_get_type(event) == FL_VALUE_TYPE_LIST, "property event must remain a list");
|
|
Check(fl_value_get_length(event) == 2, "property event must contain the ID and value");
|
|
Check(fl_value_get_int(fl_value_get_list_value(event, 0)) == 42, "property event ID changed");
|
|
Check(
|
|
fl_value_get_type(fl_value_get_list_value(event, 1)) == FL_VALUE_TYPE_NULL,
|
|
"a missing MPV node payload must decode as null");
|
|
delivered = true;
|
|
});
|
|
|
|
mpv_event_property property{};
|
|
property.name = "track-list";
|
|
property.format = MPV_FORMAT_NODE;
|
|
property.data = nullptr;
|
|
mpv_event event{};
|
|
event.event_id = MPV_EVENT_PROPERTY_CHANGE;
|
|
event.data = &property;
|
|
MpvPlayerLifecycleTestPeer::HandleEvent(player, &event);
|
|
Check(delivered, "null node property event was not delivered");
|
|
}
|
|
|
|
void TestUnavailableCommandFails() {
|
|
MpvPlayer player;
|
|
int callback_count = 0;
|
|
int status = MPV_ERROR_SUCCESS;
|
|
|
|
player.CommandAsync({"stop"}, [&](int error) {
|
|
++callback_count;
|
|
status = error;
|
|
});
|
|
|
|
Check(callback_count == 1, "a command without an mpv handle must complete exactly once");
|
|
Check(status == MPV_ERROR_UNINITIALIZED, "a command without an mpv handle must fail as uninitialized");
|
|
}
|
|
|
|
void TestUnavailablePropertyWriteFails() {
|
|
MpvPlayer player;
|
|
int callback_count = 0;
|
|
int status = MPV_ERROR_SUCCESS;
|
|
|
|
player.SetPropertyAsync("pause", "yes", [&](int error) {
|
|
++callback_count;
|
|
status = error;
|
|
});
|
|
|
|
Check(callback_count == 1, "a property write without an mpv handle must complete exactly once");
|
|
Check(status == MPV_ERROR_UNINITIALIZED, "a property write without an mpv handle must fail as uninitialized");
|
|
}
|
|
|
|
void TestPendingPropertyWriteFailsOnDispose() {
|
|
MpvPlayer player;
|
|
int callback_count = 0;
|
|
int status = MPV_ERROR_SUCCESS;
|
|
MpvPlayerLifecycleTestPeer::RegisterPendingPropertyWrite(player, [&](int error) {
|
|
++callback_count;
|
|
status = error;
|
|
});
|
|
|
|
player.Dispose();
|
|
Check(callback_count == 1, "dispose must complete a pending property write exactly once");
|
|
Check(status == MPV_ERROR_UNINITIALIZED, "dispose must cancel a pending property write as uninitialized");
|
|
|
|
player.Dispose();
|
|
Check(callback_count == 1, "repeated dispose must not complete a property write twice");
|
|
}
|
|
|
|
void TestQueuedSourcesAreRetired(GMainContext* context) {
|
|
int redraws = 0;
|
|
auto player = std::make_unique<MpvPlayer>();
|
|
auto callback_context = MpvPlayerLifecycleTestPeer::RetainContext(*player);
|
|
player->SetRedrawCallback([&redraws]() { ++redraws; });
|
|
|
|
MpvPlayerLifecycleTestPeer::Wakeup(callback_context);
|
|
MpvPlayerLifecycleTestPeer::RenderUpdate(callback_context);
|
|
MpvPlayerLifecycleTestPeer::ScheduleRecovery(*player);
|
|
Check(MpvPlayerLifecycleTestPeer::PendingSourceCount(*player) == 3, "all player sources must be tracked");
|
|
|
|
player->Dispose();
|
|
Check(MpvPlayerLifecycleTestPeer::PendingSourceCount(*player) == 0, "dispose must retire every tracked source");
|
|
player.reset();
|
|
|
|
MpvPlayerLifecycleTestPeer::Wakeup(callback_context);
|
|
MpvPlayerLifecycleTestPeer::RenderUpdate(callback_context);
|
|
Drain(context);
|
|
Check(redraws == 0, "detached callbacks must not publish redraws");
|
|
}
|
|
|
|
void TestNativeLeaseBlocksDispose() {
|
|
auto player = std::make_unique<MpvPlayer>();
|
|
auto callback_context = MpvPlayerLifecycleTestPeer::RetainContext(*player);
|
|
std::mutex mutex;
|
|
std::condition_variable condition;
|
|
bool entered = false;
|
|
bool release = false;
|
|
|
|
std::thread holder(
|
|
[&]() { MpvPlayerLifecycleTestPeer::HoldLease(callback_context, mutex, condition, entered, release); });
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
condition.wait(lock, [&entered]() { return entered; });
|
|
}
|
|
|
|
std::atomic<bool> disposed{false};
|
|
std::thread disposer([&]() {
|
|
player->Dispose();
|
|
disposed = true;
|
|
});
|
|
MpvPlayerLifecycleTestPeer::WaitUntilDetached(callback_context);
|
|
Check(!disposed.load(), "dispose returned while a native callback lease was active");
|
|
|
|
{
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
release = true;
|
|
}
|
|
condition.notify_all();
|
|
holder.join();
|
|
disposer.join();
|
|
Check(disposed.load(), "dispose did not finish after the native callback lease was released");
|
|
|
|
player.reset();
|
|
MpvPlayerLifecycleTestPeer::Wakeup(callback_context);
|
|
MpvPlayerLifecycleTestPeer::RenderUpdate(callback_context);
|
|
}
|
|
|
|
void TestWakeupAndRedrawCoalesce(GMainContext* context) {
|
|
int redraws = 0;
|
|
MpvPlayer player;
|
|
auto callback_context = MpvPlayerLifecycleTestPeer::RetainContext(player);
|
|
player.SetRedrawCallback([&redraws]() { ++redraws; });
|
|
|
|
for (int i = 0; i < 10; ++i) {
|
|
MpvPlayerLifecycleTestPeer::Wakeup(callback_context);
|
|
MpvPlayerLifecycleTestPeer::RenderUpdate(callback_context);
|
|
}
|
|
Check(MpvPlayerLifecycleTestPeer::PendingSourceCount(player) == 2, "wakeup and redraw sources must coalesce");
|
|
Drain(context);
|
|
Check(redraws == 1, "coalesced redraw was not delivered exactly once");
|
|
Check(MpvPlayerLifecycleTestPeer::PendingSourceCount(player) == 0, "dispatched source IDs must be cleared");
|
|
|
|
player.ClearRedrawFlag();
|
|
MpvPlayerLifecycleTestPeer::RenderUpdate(callback_context);
|
|
Drain(context);
|
|
Check(redraws == 2, "a redraw after dispatch must still be delivered");
|
|
}
|
|
|
|
void TestRapidReplacementCannotReceiveOldCallbacks(GMainContext* context) {
|
|
for (int iteration = 0; iteration < 100; ++iteration) {
|
|
int old_redraws = 0;
|
|
int replacement_redraws = 0;
|
|
|
|
auto old_player = std::make_unique<MpvPlayer>();
|
|
auto old_context = MpvPlayerLifecycleTestPeer::RetainContext(*old_player);
|
|
old_player->SetRedrawCallback([&old_redraws]() { ++old_redraws; });
|
|
MpvPlayerLifecycleTestPeer::Wakeup(old_context);
|
|
MpvPlayerLifecycleTestPeer::RenderUpdate(old_context);
|
|
old_player->Dispose();
|
|
old_player.reset();
|
|
|
|
auto replacement = std::make_unique<MpvPlayer>();
|
|
auto replacement_context = MpvPlayerLifecycleTestPeer::RetainContext(*replacement);
|
|
replacement->SetRedrawCallback([&replacement_redraws]() { ++replacement_redraws; });
|
|
|
|
// Simulate both an entered-old callback resuming and fresh replacement work.
|
|
MpvPlayerLifecycleTestPeer::Wakeup(old_context);
|
|
MpvPlayerLifecycleTestPeer::RenderUpdate(old_context);
|
|
MpvPlayerLifecycleTestPeer::Wakeup(replacement_context);
|
|
MpvPlayerLifecycleTestPeer::RenderUpdate(replacement_context);
|
|
Drain(context);
|
|
|
|
Check(old_redraws == 0, "an old redraw callback ran after replacement");
|
|
Check(replacement_redraws == 1, "old callback state suppressed or duplicated a replacement redraw");
|
|
replacement->Dispose();
|
|
}
|
|
}
|
|
|
|
void TestRenderTeardownRetainsOwnershipUntilContextIsCurrent() {
|
|
NativeRenderTeardownBatch batch;
|
|
auto* render = reinterpret_cast<mpv_render_context*>(1);
|
|
auto* handle = reinterpret_cast<mpv_handle*>(2);
|
|
auto display = reinterpret_cast<EGLDisplay>(3);
|
|
auto context = reinterpret_cast<EGLContext>(4);
|
|
batch.resources.push_back({render, display, context});
|
|
batch.handle = handle;
|
|
|
|
bool allow_make_current = false;
|
|
bool allow_release = true;
|
|
int make_current_calls = 0;
|
|
int release_calls = 0;
|
|
int free_calls = 0;
|
|
int destroy_calls = 0;
|
|
int terminate_calls = 0;
|
|
NativeRenderTeardownOperations operations{
|
|
[&](EGLDisplay actual_display, EGLContext actual_context) {
|
|
Check(actual_display == display && actual_context == context, "teardown must bind the retained EGL context");
|
|
++make_current_calls;
|
|
return allow_make_current;
|
|
},
|
|
[&](EGLDisplay actual_display) {
|
|
Check(actual_display == display, "teardown must release the retained EGL display");
|
|
++release_calls;
|
|
return allow_release;
|
|
},
|
|
[&](EGLDisplay actual_display, EGLContext actual_context) {
|
|
Check(actual_display == display && actual_context == context, "teardown destroyed the wrong EGL context");
|
|
++destroy_calls;
|
|
return true;
|
|
},
|
|
[&](mpv_render_context* actual_render) {
|
|
Check(actual_render == render, "teardown freed the wrong render context");
|
|
++free_calls;
|
|
},
|
|
[&](mpv_handle* actual_handle) {
|
|
Check(actual_handle == handle, "teardown terminated the wrong mpv handle");
|
|
++terminate_calls;
|
|
},
|
|
};
|
|
|
|
Check(!TryReleaseNativeRenderTeardown(batch, operations), "a failed EGL bind must retain the native teardown batch");
|
|
Check(make_current_calls == 1, "teardown must attempt to bind the required EGL context");
|
|
Check(
|
|
free_calls == 0 && release_calls == 0 && destroy_calls == 0 && terminate_calls == 0,
|
|
"a failed EGL bind must not free, destroy, or terminate dependent native objects");
|
|
Check(
|
|
batch.resources.size() == 1 && batch.resources.front().render == render && batch.handle == handle,
|
|
"a failed EGL bind must preserve complete ownership for retry");
|
|
|
|
allow_make_current = true;
|
|
Check(TryReleaseNativeRenderTeardown(batch, operations), "a later valid EGL bind must complete retained teardown");
|
|
Check(batch.resources.empty() && batch.handle == nullptr, "successful retry must consume the teardown batch");
|
|
Check(
|
|
free_calls == 1 && release_calls == 1 && destroy_calls == 1 && terminate_calls == 1,
|
|
"successful retry must release the render, EGL context, and then the shared handle exactly once");
|
|
}
|
|
|
|
void TestRenderTeardownDoesNotDestroyAStillCurrentContext() {
|
|
NativeRenderTeardownBatch batch;
|
|
auto* render = reinterpret_cast<mpv_render_context*>(5);
|
|
auto* handle = reinterpret_cast<mpv_handle*>(6);
|
|
auto display = reinterpret_cast<EGLDisplay>(7);
|
|
auto context = reinterpret_cast<EGLContext>(8);
|
|
batch.resources.push_back({render, display, context});
|
|
batch.handle = handle;
|
|
|
|
bool allow_release = false;
|
|
int free_calls = 0;
|
|
int destroy_calls = 0;
|
|
int terminate_calls = 0;
|
|
NativeRenderTeardownOperations operations{
|
|
[](EGLDisplay, EGLContext) { return true; },
|
|
[&](EGLDisplay) { return allow_release; },
|
|
[&](EGLDisplay, EGLContext) {
|
|
++destroy_calls;
|
|
return true;
|
|
},
|
|
[&](mpv_render_context*) { ++free_calls; },
|
|
[&](mpv_handle*) { ++terminate_calls; },
|
|
};
|
|
|
|
Check(!TryReleaseNativeRenderTeardown(batch, operations), "a context that cannot be released must remain queued");
|
|
Check(free_calls == 1, "the render context may be freed only after its EGL context became current");
|
|
Check(
|
|
destroy_calls == 0 && terminate_calls == 0 && batch.resources.front().render == nullptr,
|
|
"failed EGL release must retain the context and handle without double-freeing the render");
|
|
|
|
allow_release = true;
|
|
Check(TryReleaseNativeRenderTeardown(batch, operations), "a later EGL release must finish teardown");
|
|
Check(
|
|
free_calls == 1 && destroy_calls == 1 && terminate_calls == 1,
|
|
"retry must not repeat render-context destruction");
|
|
}
|
|
|
|
void TestRetainedRenderBlocksAnotherCreationUntilReleased() {
|
|
std::vector<NativeRenderTeardownResource> retained{
|
|
{reinterpret_cast<mpv_render_context*>(9), reinterpret_cast<EGLDisplay>(10), reinterpret_cast<EGLContext>(11)}};
|
|
bool allow_make_current = false;
|
|
int free_calls = 0;
|
|
int destroy_calls = 0;
|
|
int render_creations = 0;
|
|
NativeRenderTeardownOperations operations{
|
|
[&](EGLDisplay, EGLContext) { return allow_make_current; },
|
|
[](EGLDisplay) { return true; },
|
|
[&](EGLDisplay, EGLContext) {
|
|
++destroy_calls;
|
|
return true;
|
|
},
|
|
[&](mpv_render_context*) { ++free_calls; },
|
|
[](mpv_handle*) { Check(false, "retained initialization cleanup must not terminate the shared core"); },
|
|
};
|
|
|
|
if (TryReleaseRetainedNativeRenderContexts(retained, operations)) ++render_creations;
|
|
Check(render_creations == 0, "a retained render context must block another creation on the same core");
|
|
Check(retained.size() == 1, "failed retained cleanup must preserve ownership for another GL-thread retry");
|
|
|
|
allow_make_current = true;
|
|
if (TryReleaseRetainedNativeRenderContexts(retained, operations)) ++render_creations;
|
|
Check(render_creations == 1, "render creation may resume after retained teardown completes");
|
|
Check(retained.empty(), "successful retained teardown must consume the old render context");
|
|
Check(free_calls == 1 && destroy_calls == 1, "retained teardown must release each native object exactly once");
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace mpv
|
|
|
|
int main() {
|
|
GMainContext* context = g_main_context_new();
|
|
g_main_context_push_thread_default(context);
|
|
|
|
try {
|
|
mpv::TestProcessShutdownDoesNotJoinBlockedNativeTeardown();
|
|
mpv::TestPopulateRetainsTextureWhileBootstrapCallbackRuns();
|
|
mpv::TestUnavailablePropertyWriteFails();
|
|
mpv::TestNodeConversionRejectsMalformedPayloads();
|
|
mpv::TestUnavailableCommandFails();
|
|
mpv::TestPendingPropertyWriteFailsOnDispose();
|
|
mpv::TestQueuedSourcesAreRetired(context);
|
|
mpv::TestNativeLeaseBlocksDispose();
|
|
mpv::TestWakeupAndRedrawCoalesce(context);
|
|
mpv::TestRapidReplacementCannotReceiveOldCallbacks(context);
|
|
mpv::TestRenderTeardownRetainsOwnershipUntilContextIsCurrent();
|
|
mpv::TestRenderTeardownDoesNotDestroyAStillCurrentContext();
|
|
mpv::TestNullNodePropertyPayloadDecodesAsNull();
|
|
mpv::TestRetainedRenderBlocksAnotherCreationUntilReleased();
|
|
} catch (const std::exception& error) {
|
|
g_main_context_pop_thread_default(context);
|
|
g_main_context_unref(context);
|
|
std::cerr << "mpv_player_lifecycle_test: " << error.what() << '\n';
|
|
return 1;
|
|
}
|
|
|
|
g_main_context_pop_thread_default(context);
|
|
g_main_context_unref(context);
|
|
std::cout << "mpv_player_lifecycle_test: PASS\n";
|
|
return 0;
|
|
}
|