mirror of
https://github.com/yuzu-mirror/yuzu.git
synced 2024-09-09 15:49:09 +01:00
kernel/event: Reference ReadableEvent from WritableEvent
This commit is contained in:
parent
ff610103b5
commit
a342bcc9b1
32 changed files with 175 additions and 317 deletions
|
@ -53,8 +53,10 @@ SharedPtr<WritableEvent> HLERequestContext::SleepClientThread(
|
|||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
if (!writable_event || !readable_event) {
|
||||
// Create event if not provided
|
||||
std::tie(writable_event, readable_event) = WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
|
||||
const auto pair = WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"HLE Pause Event: " + reason);
|
||||
writable_event = pair.writable;
|
||||
readable_event = pair.readable;
|
||||
}
|
||||
|
||||
writable_event->Clear();
|
||||
|
|
|
@ -177,10 +177,6 @@ struct KernelCore::Impl {
|
|||
// allowing us to simply use a pool index or similar.
|
||||
Kernel::HandleTable thread_wakeup_callback_handle_table;
|
||||
|
||||
/// Map of named events managed by the kernel, which are retrieved when HLE services need to
|
||||
/// return an event to the system.
|
||||
NamedEventTable named_events;
|
||||
|
||||
/// Map of named ports managed by the kernel, which can be retrieved using
|
||||
/// the ConnectToPort SVC.
|
||||
NamedPortTable named_ports;
|
||||
|
@ -227,19 +223,6 @@ const Process* KernelCore::CurrentProcess() const {
|
|||
return impl->current_process;
|
||||
}
|
||||
|
||||
void KernelCore::AddNamedEvent(std::string name, SharedPtr<ReadableEvent> event) {
|
||||
impl->named_events.emplace(std::move(name), std::move(event));
|
||||
}
|
||||
|
||||
KernelCore::NamedEventTable::iterator KernelCore::FindNamedEvent(const std::string& name) {
|
||||
return impl->named_events.find(name);
|
||||
}
|
||||
|
||||
KernelCore::NamedEventTable::const_iterator KernelCore::FindNamedEvent(
|
||||
const std::string& name) const {
|
||||
return impl->named_events.find(name);
|
||||
}
|
||||
|
||||
void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
|
||||
impl->named_ports.emplace(std::move(name), std::move(port));
|
||||
}
|
||||
|
|
|
@ -20,7 +20,6 @@ namespace Kernel {
|
|||
class ClientPort;
|
||||
class HandleTable;
|
||||
class Process;
|
||||
class ReadableEvent;
|
||||
class ResourceLimit;
|
||||
class Thread;
|
||||
class Timer;
|
||||
|
@ -28,7 +27,6 @@ class Timer;
|
|||
/// Represents a single instance of the kernel.
|
||||
class KernelCore {
|
||||
private:
|
||||
using NamedEventTable = std::unordered_map<std::string, SharedPtr<ReadableEvent>>;
|
||||
using NamedPortTable = std::unordered_map<std::string, SharedPtr<ClientPort>>;
|
||||
|
||||
public:
|
||||
|
@ -68,15 +66,6 @@ public:
|
|||
/// Retrieves a const pointer to the current process.
|
||||
const Process* CurrentProcess() const;
|
||||
|
||||
/// Adds an event to the named event table
|
||||
void AddNamedEvent(std::string name, SharedPtr<ReadableEvent> event);
|
||||
|
||||
/// Finds an event within the named event table wit the given name.
|
||||
NamedEventTable::iterator FindNamedEvent(const std::string& name);
|
||||
|
||||
/// Finds an event within the named event table wit the given name.
|
||||
NamedEventTable::const_iterator FindNamedEvent(const std::string& name) const;
|
||||
|
||||
/// Adds a port to the named port table
|
||||
void AddNamedPort(std::string name, SharedPtr<ClientPort> port);
|
||||
|
||||
|
|
|
@ -15,34 +15,30 @@ ReadableEvent::ReadableEvent(KernelCore& kernel) : WaitObject{kernel} {}
|
|||
ReadableEvent::~ReadableEvent() = default;
|
||||
|
||||
bool ReadableEvent::ShouldWait(Thread* thread) const {
|
||||
return !writable_event->IsSignaled();
|
||||
return !signaled;
|
||||
}
|
||||
|
||||
void ReadableEvent::Acquire(Thread* thread) {
|
||||
ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
|
||||
|
||||
writable_event->ResetOnAcquire();
|
||||
}
|
||||
|
||||
void ReadableEvent::AddWaitingThread(SharedPtr<Thread> thread) {
|
||||
writable_event->AddWaitingThread(thread);
|
||||
}
|
||||
|
||||
void ReadableEvent::RemoveWaitingThread(Thread* thread) {
|
||||
writable_event->RemoveWaitingThread(thread);
|
||||
if (reset_type == ResetType::OneShot)
|
||||
signaled = false;
|
||||
}
|
||||
|
||||
void ReadableEvent::Signal() {
|
||||
writable_event->Signal();
|
||||
signaled = true;
|
||||
WakeupAllWaitingThreads();
|
||||
}
|
||||
|
||||
void ReadableEvent::Clear() {
|
||||
writable_event->Clear();
|
||||
signaled = false;
|
||||
}
|
||||
|
||||
void ReadableEvent::WakeupAllWaitingThreads() {
|
||||
writable_event->WakeupAllWaitingThreads();
|
||||
writable_event->ResetOnWakeup();
|
||||
WaitObject::WakeupAllWaitingThreads();
|
||||
|
||||
if (reset_type == ResetType::Pulse)
|
||||
signaled = false;
|
||||
}
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -25,6 +25,10 @@ public:
|
|||
return name;
|
||||
}
|
||||
|
||||
ResetType GetResetType() const {
|
||||
return reset_type;
|
||||
}
|
||||
|
||||
static const HandleType HANDLE_TYPE = HandleType::Event;
|
||||
HandleType GetHandleType() const override {
|
||||
return HANDLE_TYPE;
|
||||
|
@ -35,20 +39,15 @@ public:
|
|||
|
||||
void WakeupAllWaitingThreads() override;
|
||||
|
||||
void AddWaitingThread(SharedPtr<Thread> thread) override;
|
||||
void RemoveWaitingThread(Thread* thread) override;
|
||||
|
||||
void Signal();
|
||||
void Clear();
|
||||
|
||||
SharedPtr<WritableEvent> PromoteToWritable() const {
|
||||
return writable_event;
|
||||
}
|
||||
|
||||
private:
|
||||
explicit ReadableEvent(KernelCore& kernel);
|
||||
|
||||
SharedPtr<WritableEvent> writable_event; ///< WritableEvent associated with this ReadableEvent
|
||||
void Signal();
|
||||
|
||||
ResetType reset_type;
|
||||
bool signaled;
|
||||
|
||||
std::string name; ///< Name of event (optional)
|
||||
};
|
||||
|
|
|
@ -1366,7 +1366,7 @@ static ResultCode ResetSignal(Handle handle) {
|
|||
|
||||
ASSERT(event != nullptr);
|
||||
|
||||
event->PromoteToWritable()->Clear();
|
||||
event->Clear();
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
|
@ -1531,7 +1531,7 @@ static ResultCode ClearEvent(Handle handle) {
|
|||
return ERR_INVALID_HANDLE;
|
||||
}
|
||||
|
||||
evt->PromoteToWritable()->Clear();
|
||||
evt->Clear();
|
||||
return RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
|
@ -12,70 +12,37 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
WritableEvent::WritableEvent(KernelCore& kernel) : WaitObject{kernel} {}
|
||||
WritableEvent::WritableEvent(KernelCore& kernel) : Object{kernel} {}
|
||||
WritableEvent::~WritableEvent() = default;
|
||||
|
||||
std::tuple<SharedPtr<WritableEvent>, SharedPtr<ReadableEvent>> WritableEvent::CreateEventPair(
|
||||
KernelCore& kernel, ResetType reset_type, std::string name) {
|
||||
EventPair WritableEvent::CreateEventPair(KernelCore& kernel, ResetType reset_type,
|
||||
std::string name) {
|
||||
SharedPtr<WritableEvent> writable_event(new WritableEvent(kernel));
|
||||
SharedPtr<ReadableEvent> readable_event(new ReadableEvent(kernel));
|
||||
|
||||
writable_event->name = name + ":Writable";
|
||||
writable_event->signaled = false;
|
||||
writable_event->reset_type = reset_type;
|
||||
writable_event->readable = readable_event;
|
||||
readable_event->name = name + ":Readable";
|
||||
readable_event->writable_event = writable_event;
|
||||
readable_event->signaled = false;
|
||||
readable_event->reset_type = reset_type;
|
||||
|
||||
return std::make_tuple(std::move(writable_event), std::move(readable_event));
|
||||
return {std::move(readable_event), std::move(writable_event)};
|
||||
}
|
||||
|
||||
SharedPtr<WritableEvent> WritableEvent::CreateRegisteredEventPair(KernelCore& kernel,
|
||||
ResetType reset_type,
|
||||
std::string name) {
|
||||
auto [writable_event, readable_event] = CreateEventPair(kernel, reset_type, name);
|
||||
kernel.AddNamedEvent(name, std::move(readable_event));
|
||||
return std::move(writable_event);
|
||||
}
|
||||
|
||||
bool WritableEvent::ShouldWait(Thread* thread) const {
|
||||
return !signaled;
|
||||
}
|
||||
|
||||
void WritableEvent::Acquire(Thread* thread) {
|
||||
ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
|
||||
|
||||
if (reset_type == ResetType::OneShot)
|
||||
signaled = false;
|
||||
ResetType WritableEvent::GetResetType() const {
|
||||
return readable->reset_type;
|
||||
}
|
||||
|
||||
void WritableEvent::Signal() {
|
||||
signaled = true;
|
||||
WakeupAllWaitingThreads();
|
||||
readable->Signal();
|
||||
}
|
||||
|
||||
void WritableEvent::Clear() {
|
||||
signaled = false;
|
||||
}
|
||||
|
||||
void WritableEvent::ResetOnAcquire() {
|
||||
if (reset_type == ResetType::OneShot)
|
||||
Clear();
|
||||
}
|
||||
|
||||
void WritableEvent::ResetOnWakeup() {
|
||||
if (reset_type == ResetType::Pulse)
|
||||
Clear();
|
||||
readable->Clear();
|
||||
}
|
||||
|
||||
bool WritableEvent::IsSignaled() const {
|
||||
return signaled;
|
||||
}
|
||||
|
||||
void WritableEvent::WakeupAllWaitingThreads() {
|
||||
WaitObject::WakeupAllWaitingThreads();
|
||||
|
||||
if (reset_type == ResetType::Pulse)
|
||||
signaled = false;
|
||||
return readable->signaled;
|
||||
}
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -12,8 +12,14 @@ namespace Kernel {
|
|||
|
||||
class KernelCore;
|
||||
class ReadableEvent;
|
||||
class WritableEvent;
|
||||
|
||||
class WritableEvent final : public WaitObject {
|
||||
struct EventPair {
|
||||
SharedPtr<ReadableEvent> readable;
|
||||
SharedPtr<WritableEvent> writable;
|
||||
};
|
||||
|
||||
class WritableEvent final : public Object {
|
||||
public:
|
||||
~WritableEvent() override;
|
||||
|
||||
|
@ -23,18 +29,8 @@ public:
|
|||
* @param reset_type ResetType describing how to create event
|
||||
* @param name Optional name of event
|
||||
*/
|
||||
static std::tuple<SharedPtr<WritableEvent>, SharedPtr<ReadableEvent>> CreateEventPair(
|
||||
KernelCore& kernel, ResetType reset_type, std::string name = "Unknown");
|
||||
|
||||
/**
|
||||
* Creates an event and registers it in the kernel's named event table
|
||||
* @param kernel The kernel instance to create this event under.
|
||||
* @param reset_type ResetType describing how to create event
|
||||
* @param name name of event
|
||||
*/
|
||||
static SharedPtr<WritableEvent> CreateRegisteredEventPair(KernelCore& kernel,
|
||||
ResetType reset_type,
|
||||
std::string name);
|
||||
static EventPair CreateEventPair(KernelCore& kernel, ResetType reset_type,
|
||||
std::string name = "Unknown");
|
||||
|
||||
std::string GetTypeName() const override {
|
||||
return "WritableEvent";
|
||||
|
@ -48,27 +44,17 @@ public:
|
|||
return HANDLE_TYPE;
|
||||
}
|
||||
|
||||
ResetType GetResetType() const {
|
||||
return reset_type;
|
||||
}
|
||||
|
||||
bool ShouldWait(Thread* thread) const override;
|
||||
void Acquire(Thread* thread) override;
|
||||
|
||||
void WakeupAllWaitingThreads() override;
|
||||
ResetType GetResetType() const;
|
||||
|
||||
void Signal();
|
||||
void Clear();
|
||||
void ResetOnAcquire();
|
||||
void ResetOnWakeup();
|
||||
bool IsSignaled() const;
|
||||
|
||||
private:
|
||||
explicit WritableEvent(KernelCore& kernel);
|
||||
|
||||
ResetType reset_type; ///< Current ResetType
|
||||
SharedPtr<ReadableEvent> readable;
|
||||
|
||||
bool signaled; ///< Whether the event has already been signaled
|
||||
std::string name; ///< Name of event (optional)
|
||||
};
|
||||
|
||||
|
|
|
@ -210,8 +210,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
launchable_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::Sticky, "ISelfController:LaunchableEvent");
|
||||
launchable_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
|
||||
"ISelfController:LaunchableEvent");
|
||||
}
|
||||
|
||||
ISelfController::~ISelfController() = default;
|
||||
|
@ -297,11 +297,11 @@ void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
|
|||
void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_AM, "(STUBBED) called");
|
||||
|
||||
launchable_event->Signal();
|
||||
launchable_event.writable->Signal();
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(launchable_event.readable);
|
||||
|
||||
void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_AM, "(STUBBED) called");
|
||||
|
@ -349,9 +349,9 @@ void ISelfController::GetIdleTimeDetectionExtension(Kernel::HLERequestContext& c
|
|||
|
||||
AppletMessageQueue::AppletMessageQueue() {
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
on_new_message = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::Sticky, "AMMessageQueue:OnMessageRecieved");
|
||||
on_operation_mode_changed = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
on_new_message = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
|
||||
"AMMessageQueue:OnMessageRecieved");
|
||||
on_operation_mode_changed = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "AMMessageQueue:OperationModeChanged");
|
||||
}
|
||||
|
||||
|
@ -359,32 +359,28 @@ AppletMessageQueue::~AppletMessageQueue() = default;
|
|||
|
||||
const Kernel::SharedPtr<Kernel::ReadableEvent>& AppletMessageQueue::GetMesssageRecieveEvent()
|
||||
const {
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OnMessageRecieved")};
|
||||
return event->second;
|
||||
return on_new_message.readable;
|
||||
}
|
||||
|
||||
const Kernel::SharedPtr<Kernel::ReadableEvent>& AppletMessageQueue::GetOperationModeChangedEvent()
|
||||
const {
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("AMMessageQueue:OperationModeChanged")};
|
||||
return event->second;
|
||||
return on_operation_mode_changed.readable;
|
||||
}
|
||||
|
||||
void AppletMessageQueue::PushMessage(AppletMessage msg) {
|
||||
messages.push(msg);
|
||||
on_new_message->Signal();
|
||||
on_new_message.writable->Signal();
|
||||
}
|
||||
|
||||
AppletMessageQueue::AppletMessage AppletMessageQueue::PopMessage() {
|
||||
if (messages.empty()) {
|
||||
on_new_message->Clear();
|
||||
on_new_message.writable->Clear();
|
||||
return AppletMessage::NoMessage;
|
||||
}
|
||||
auto msg = messages.front();
|
||||
messages.pop();
|
||||
if (messages.empty()) {
|
||||
on_new_message->Clear();
|
||||
on_new_message.writable->Clear();
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
|
@ -396,7 +392,7 @@ std::size_t AppletMessageQueue::GetMessageCount() const {
|
|||
void AppletMessageQueue::OperationModeChanged() {
|
||||
PushMessage(AppletMessage::OperationModeChanged);
|
||||
PushMessage(AppletMessage::PerformanceModeChanged);
|
||||
on_operation_mode_changed->Signal();
|
||||
on_operation_mode_changed.writable->Signal();
|
||||
}
|
||||
|
||||
ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue)
|
||||
|
|
|
@ -6,13 +6,9 @@
|
|||
|
||||
#include <memory>
|
||||
#include <queue>
|
||||
#include "core/hle/kernel/writable_event.h"
|
||||
#include "core/hle/service/service.h"
|
||||
|
||||
namespace Kernel {
|
||||
class ReadableEvent;
|
||||
class WritableEvent;
|
||||
} // namespace Kernel
|
||||
|
||||
namespace Service {
|
||||
namespace NVFlinger {
|
||||
class NVFlinger;
|
||||
|
@ -62,8 +58,8 @@ public:
|
|||
|
||||
private:
|
||||
std::queue<AppletMessage> messages;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> on_new_message;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> on_operation_mode_changed;
|
||||
Kernel::EventPair on_new_message;
|
||||
Kernel::EventPair on_operation_mode_changed;
|
||||
};
|
||||
|
||||
class IWindowController final : public ServiceFramework<IWindowController> {
|
||||
|
@ -123,7 +119,7 @@ private:
|
|||
void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
|
||||
|
||||
std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> launchable_event;
|
||||
Kernel::EventPair launchable_event;
|
||||
u32 idle_time_detection_extension = 0;
|
||||
};
|
||||
|
||||
|
|
|
@ -15,11 +15,11 @@ namespace Service::AM::Applets {
|
|||
|
||||
AppletDataBroker::AppletDataBroker() {
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
state_changed_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
state_changed_event = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:StateChangedEvent");
|
||||
pop_out_data_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
pop_out_data_event = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopDataOutEvent");
|
||||
pop_interactive_out_data_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
pop_interactive_out_data_event = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "ILibraryAppletAccessor:PopInteractiveDataOutEvent");
|
||||
}
|
||||
|
||||
|
@ -67,7 +67,7 @@ void AppletDataBroker::PushNormalDataFromGame(IStorage storage) {
|
|||
|
||||
void AppletDataBroker::PushNormalDataFromApplet(IStorage storage) {
|
||||
out_channel.push(std::make_unique<IStorage>(storage));
|
||||
pop_out_data_event->Signal();
|
||||
pop_out_data_event.writable->Signal();
|
||||
}
|
||||
|
||||
void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) {
|
||||
|
@ -76,29 +76,23 @@ void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) {
|
|||
|
||||
void AppletDataBroker::PushInteractiveDataFromApplet(IStorage storage) {
|
||||
out_interactive_channel.push(std::make_unique<IStorage>(storage));
|
||||
pop_interactive_out_data_event->Signal();
|
||||
pop_interactive_out_data_event.writable->Signal();
|
||||
}
|
||||
|
||||
void AppletDataBroker::SignalStateChanged() const {
|
||||
state_changed_event->Signal();
|
||||
state_changed_event.writable->Signal();
|
||||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetNormalDataEvent() const {
|
||||
const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
|
||||
"ILibraryAppletAccessor:PopDataOutEvent")};
|
||||
return event->second;
|
||||
return pop_out_data_event.readable;
|
||||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetInteractiveDataEvent() const {
|
||||
const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
|
||||
"ILibraryAppletAccessor:PopInteractiveDataOutEvent")};
|
||||
return event->second;
|
||||
return pop_interactive_out_data_event.readable;
|
||||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetStateChangedEvent() const {
|
||||
const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
|
||||
"ILibraryAppletAccessor:StateChangedEvent")};
|
||||
return event->second;
|
||||
return state_changed_event.readable;
|
||||
}
|
||||
|
||||
Applet::Applet() = default;
|
||||
|
|
|
@ -60,13 +60,13 @@ private:
|
|||
// PopInteractiveDataToGame and PushInteractiveDataFromApplet
|
||||
std::queue<std::unique_ptr<IStorage>> out_interactive_channel;
|
||||
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> state_changed_event;
|
||||
Kernel::EventPair state_changed_event;
|
||||
|
||||
// Signaled on PushNormalDataFromApplet
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> pop_out_data_event;
|
||||
Kernel::EventPair pop_out_data_event;
|
||||
|
||||
// Signaled on PushInteractiveDataFromApplet
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> pop_interactive_out_data_event;
|
||||
Kernel::EventPair pop_interactive_out_data_event;
|
||||
};
|
||||
|
||||
class Applet {
|
||||
|
|
|
@ -63,8 +63,8 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
aoc_change_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::Sticky, "GetAddOnContentListChanged:Event");
|
||||
aoc_change_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
|
||||
"GetAddOnContentListChanged:Event");
|
||||
}
|
||||
|
||||
AOC_U::~AOC_U() = default;
|
||||
|
@ -144,12 +144,9 @@ void AOC_U::PrepareAddOnContent(Kernel::HLERequestContext& ctx) {
|
|||
void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_AOC, "(STUBBED) called");
|
||||
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("GetAddOnContentListChanged:Event")};
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(aoc_change_event.readable);
|
||||
}
|
||||
|
||||
void InstallInterfaces(SM::ServiceManager& service_manager) {
|
||||
|
|
|
@ -25,7 +25,7 @@ private:
|
|||
void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
|
||||
|
||||
std::vector<u64> add_on_content;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> aoc_change_event;
|
||||
Kernel::EventPair aoc_change_event;
|
||||
};
|
||||
|
||||
/// Registers all AOC services with the specified service manager.
|
||||
|
|
|
@ -69,11 +69,12 @@ public:
|
|||
|
||||
// This is the event handle used to check if the audio buffer was released
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
buffer_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::Sticky, "IAudioOutBufferReleased");
|
||||
buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
|
||||
"IAudioOutBufferReleased");
|
||||
|
||||
stream = audio_core.OpenStream(audio_params.sample_rate, audio_params.channel_count,
|
||||
std::move(unique_name), [=]() { buffer_event->Signal(); });
|
||||
std::move(unique_name),
|
||||
[=]() { buffer_event.writable->Signal(); });
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -123,9 +124,7 @@ private:
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IAudioOutBufferReleased")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(buffer_event.readable);
|
||||
}
|
||||
|
||||
void AppendAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -191,8 +190,8 @@ private:
|
|||
|
||||
AudoutParams audio_params{};
|
||||
|
||||
/// This is the evend handle used to check if the audio buffer was released
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> buffer_event;
|
||||
/// This is the event handle used to check if the audio buffer was released
|
||||
Kernel::EventPair buffer_event;
|
||||
};
|
||||
|
||||
void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
|
||||
|
|
|
@ -43,14 +43,14 @@ public:
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
system_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::Sticky, "IAudioRenderer:SystemEvent");
|
||||
renderer = std::make_unique<AudioCore::AudioRenderer>(audren_params, system_event);
|
||||
system_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
|
||||
"IAudioRenderer:SystemEvent");
|
||||
renderer = std::make_unique<AudioCore::AudioRenderer>(audren_params, system_event.writable);
|
||||
}
|
||||
|
||||
private:
|
||||
void UpdateAudioCallback() {
|
||||
system_event->Signal();
|
||||
system_event.writable->Signal();
|
||||
}
|
||||
|
||||
void GetSampleRate(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -114,9 +114,7 @@ private:
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IAudioRenderer:SystemEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(system_event.readable);
|
||||
}
|
||||
|
||||
void SetRenderingTimeLimit(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -139,7 +137,7 @@ private:
|
|||
rb.Push(rendering_time_limit_percent);
|
||||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> system_event;
|
||||
Kernel::EventPair system_event;
|
||||
std::unique_ptr<AudioCore::AudioRenderer> renderer;
|
||||
u32 rendering_time_limit_percent = 100;
|
||||
};
|
||||
|
@ -166,8 +164,8 @@ public:
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
buffer_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IAudioOutBufferReleasedEvent");
|
||||
buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"IAudioOutBufferReleasedEvent");
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -211,13 +209,11 @@ private:
|
|||
void QueryAudioDeviceSystemEvent(Kernel::HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_Audio, "(STUBBED) called");
|
||||
|
||||
buffer_event->Signal();
|
||||
buffer_event.writable->Signal();
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IAudioOutBufferReleasedEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(buffer_event.readable);
|
||||
}
|
||||
|
||||
void GetActiveChannelCount(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -228,7 +224,7 @@ private:
|
|||
rb.Push<u32>(1);
|
||||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> buffer_event;
|
||||
Kernel::EventPair buffer_event;
|
||||
|
||||
}; // namespace Audio
|
||||
|
||||
|
|
|
@ -34,8 +34,8 @@ public:
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
register_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "BT:RegisterEvent");
|
||||
register_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"BT:RegisterEvent");
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -44,10 +44,10 @@ private:
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("BT:RegisterEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(register_event.readable);
|
||||
}
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> register_event;
|
||||
|
||||
Kernel::EventPair register_event;
|
||||
};
|
||||
|
||||
class BtDrv final : public ServiceFramework<BtDrv> {
|
||||
|
|
|
@ -57,14 +57,14 @@ public:
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
scan_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ScanEvent");
|
||||
connection_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
scan_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"IBtmUserCore:ScanEvent");
|
||||
connection_event = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConnectionEvent");
|
||||
service_discovery = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
service_discovery = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IBtmUserCore:Discovery");
|
||||
config_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IBtmUserCore:ConfigEvent");
|
||||
config_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"IBtmUserCore:ConfigEvent");
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -73,46 +73,37 @@ private:
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ScanEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(scan_event.readable);
|
||||
}
|
||||
|
||||
void GetConnectionEvent(Kernel::HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_BTM, "(STUBBED) called");
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ConnectionEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(connection_event.readable);
|
||||
}
|
||||
|
||||
void GetDiscoveryEvent(Kernel::HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_BTM, "(STUBBED) called");
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:Discovery")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(service_discovery.readable);
|
||||
}
|
||||
|
||||
void GetConfigEvent(Kernel::HLERequestContext& ctx) {
|
||||
LOG_WARNING(Service_BTM, "(STUBBED) called");
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IBtmUserCore:ConfigEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(config_event.readable);
|
||||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> scan_event;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> connection_event;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> service_discovery;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> config_event;
|
||||
Kernel::EventPair scan_event;
|
||||
Kernel::EventPair connection_event;
|
||||
Kernel::EventPair service_discovery;
|
||||
Kernel::EventPair config_event;
|
||||
};
|
||||
|
||||
class BTM_USR final : public ServiceFramework<BTM_USR> {
|
||||
|
|
|
@ -169,7 +169,7 @@ void Controller_NPad::InitNewlyAddedControler(std::size_t controller_idx) {
|
|||
|
||||
void Controller_NPad::OnInit() {
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
styleset_changed_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
styleset_changed_event = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "npad:NpadStyleSetChanged");
|
||||
|
||||
if (!IsControllerActivated()) {
|
||||
|
@ -496,7 +496,7 @@ void Controller_NPad::SetSupportedNPadIdTypes(u8* data, std::size_t length) {
|
|||
had_controller_update = true;
|
||||
}
|
||||
if (had_controller_update) {
|
||||
styleset_changed_event->Signal();
|
||||
styleset_changed_event.writable->Signal();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -511,7 +511,7 @@ std::size_t Controller_NPad::GetSupportedNPadIdTypesSize() const {
|
|||
}
|
||||
|
||||
void Controller_NPad::SetHoldType(NpadHoldType joy_hold_type) {
|
||||
styleset_changed_event->Signal();
|
||||
styleset_changed_event.writable->Signal();
|
||||
hold_type = joy_hold_type;
|
||||
}
|
||||
|
||||
|
@ -543,10 +543,8 @@ void Controller_NPad::VibrateController(const std::vector<u32>& controller_ids,
|
|||
Kernel::SharedPtr<Kernel::ReadableEvent> Controller_NPad::GetStyleSetChangedEvent() const {
|
||||
// TODO(ogniK): Figure out the best time to signal this event. This event seems that it should
|
||||
// be signalled at least once, and signaled after a new controller is connected?
|
||||
styleset_changed_event->Signal();
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("npad:NpadStyleSetChanged")};
|
||||
return event->second;
|
||||
styleset_changed_event.writable->Signal();
|
||||
return styleset_changed_event.readable;
|
||||
}
|
||||
|
||||
Controller_NPad::Vibration Controller_NPad::GetLastVibration() const {
|
||||
|
|
|
@ -9,14 +9,10 @@
|
|||
#include "common/common_types.h"
|
||||
#include "core/frontend/input.h"
|
||||
#include "core/hle/kernel/object.h"
|
||||
#include "core/hle/kernel/writable_event.h"
|
||||
#include "core/hle/service/hid/controllers/controller_base.h"
|
||||
#include "core/settings.h"
|
||||
|
||||
namespace Kernel {
|
||||
class ReadableEvent;
|
||||
class WritableEvent;
|
||||
} // namespace Kernel
|
||||
|
||||
namespace Service::HID {
|
||||
|
||||
constexpr u32 NPAD_HANDHELD = 32;
|
||||
|
@ -308,7 +304,7 @@ private:
|
|||
sticks;
|
||||
std::vector<u32> supported_npad_id_types{};
|
||||
NpadHoldType hold_type{NpadHoldType::Vertical};
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> styleset_changed_event;
|
||||
Kernel::EventPair styleset_changed_event;
|
||||
Vibration last_processed_vibration{};
|
||||
std::array<ControllerHolder, 10> connected_controllers{};
|
||||
bool can_controllers_vibrate{true};
|
||||
|
|
|
@ -25,8 +25,8 @@ constexpr ResultCode ERR_TAG_FAILED(ErrorModule::NFP,
|
|||
Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
|
||||
: ServiceFramework(name), module(std::move(module)) {
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
nfc_tag_load = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IUser:NFCTagDetected");
|
||||
nfc_tag_load = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"IUser:NFCTagDetected");
|
||||
}
|
||||
|
||||
Module::Interface::~Interface() = default;
|
||||
|
@ -65,9 +65,9 @@ public:
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
deactivate_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
deactivate_event = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IUser:DeactivateEvent");
|
||||
availability_change_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
availability_change_event = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IUser:AvailabilityChangeEvent");
|
||||
}
|
||||
|
||||
|
@ -166,10 +166,7 @@ private:
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IUser:DeactivateEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(deactivate_event.readable);
|
||||
}
|
||||
|
||||
void StopDetection(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -178,7 +175,7 @@ private:
|
|||
switch (device_state) {
|
||||
case DeviceState::TagFound:
|
||||
case DeviceState::TagNearby:
|
||||
deactivate_event->Signal();
|
||||
deactivate_event.writable->Signal();
|
||||
device_state = DeviceState::Initialized;
|
||||
break;
|
||||
case DeviceState::SearchingForTag:
|
||||
|
@ -269,9 +266,7 @@ private:
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("IUser:AvailabilityChangeEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(availability_change_event.readable);
|
||||
}
|
||||
|
||||
void GetRegisterInfo(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -326,8 +321,8 @@ private:
|
|||
const u32 npad_id{0}; // Player 1 controller
|
||||
State state{State::NonInitialized};
|
||||
DeviceState device_state{DeviceState::Initialized};
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> deactivate_event;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> availability_change_event;
|
||||
Kernel::EventPair deactivate_event;
|
||||
Kernel::EventPair availability_change_event;
|
||||
const Module::Interface& nfp_interface;
|
||||
};
|
||||
|
||||
|
@ -346,14 +341,14 @@ bool Module::Interface::LoadAmiibo(const std::vector<u8>& buffer) {
|
|||
}
|
||||
|
||||
std::memcpy(&amiibo, buffer.data(), sizeof(amiibo));
|
||||
nfc_tag_load->Signal();
|
||||
nfc_tag_load.writable->Signal();
|
||||
return true;
|
||||
}
|
||||
|
||||
const Kernel::SharedPtr<Kernel::ReadableEvent>& Module::Interface::GetNFCEvent() const {
|
||||
const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("IUser:NFCTagDetected")};
|
||||
return event->second;
|
||||
return nfc_tag_load.readable;
|
||||
}
|
||||
|
||||
const Module::Interface::AmiiboFile& Module::Interface::GetAmiiboBuffer() const {
|
||||
return amiibo;
|
||||
}
|
||||
|
|
|
@ -6,13 +6,9 @@
|
|||
|
||||
#include <array>
|
||||
#include <vector>
|
||||
#include "core/hle/kernel/writable_event.h"
|
||||
#include "core/hle/service/service.h"
|
||||
|
||||
namespace Kernel {
|
||||
class ReadableEvent;
|
||||
class WritableEvent;
|
||||
} // namespace Kernel
|
||||
|
||||
namespace Service::NFP {
|
||||
|
||||
class Module final {
|
||||
|
@ -41,7 +37,7 @@ public:
|
|||
const AmiiboFile& GetAmiiboBuffer() const;
|
||||
|
||||
private:
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> nfc_tag_load{};
|
||||
Kernel::EventPair nfc_tag_load{};
|
||||
AmiiboFile amiibo{};
|
||||
|
||||
protected:
|
||||
|
|
|
@ -58,10 +58,10 @@ public:
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
event1 = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IRequest:Event1");
|
||||
event2 = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "IRequest:Event2");
|
||||
event1 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"IRequest:Event1");
|
||||
event2 = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"IRequest:Event2");
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -92,11 +92,7 @@ private:
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 2};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
const auto& event1{Core::System::GetInstance().Kernel().FindNamedEvent("IRequest:Event1")};
|
||||
const auto& event2{Core::System::GetInstance().Kernel().FindNamedEvent("IRequest:Event2")};
|
||||
|
||||
rb.PushCopyObjects(event1->second, event2->second);
|
||||
rb.PushCopyObjects(event1.readable, event2.readable);
|
||||
}
|
||||
|
||||
void Cancel(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -113,7 +109,7 @@ private:
|
|||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> event1, event2;
|
||||
Kernel::EventPair event1, event2;
|
||||
};
|
||||
|
||||
class INetworkProfile final : public ServiceFramework<INetworkProfile> {
|
||||
|
|
|
@ -140,19 +140,18 @@ public:
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
finished_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
finished_event = Kernel::WritableEvent::CreateEventPair(
|
||||
kernel, Kernel::ResetType::OneShot,
|
||||
"IEnsureNetworkClockAvailabilityService:FinishEvent");
|
||||
}
|
||||
|
||||
private:
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> finished_event;
|
||||
Kernel::EventPair finished_event;
|
||||
|
||||
void StartTask(Kernel::HLERequestContext& ctx) {
|
||||
// No need to connect to the internet, just finish the task straight away.
|
||||
LOG_DEBUG(Service_NIM, "called");
|
||||
|
||||
finished_event->Signal();
|
||||
finished_event.writable->Signal();
|
||||
IPC::ResponseBuilder rb{ctx, 2};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
@ -162,9 +161,7 @@ private:
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
|
||||
"IEnsureNetworkClockAvailabilityService:FinishEvent")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(finished_event.readable);
|
||||
}
|
||||
|
||||
void GetResult(Kernel::HLERequestContext& ctx) {
|
||||
|
@ -176,8 +173,7 @@ private:
|
|||
|
||||
void Cancel(Kernel::HLERequestContext& ctx) {
|
||||
LOG_DEBUG(Service_NIM, "called");
|
||||
|
||||
finished_event->Clear();
|
||||
finished_event.writable->Clear();
|
||||
IPC::ResponseBuilder rb{ctx, 2};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
}
|
||||
|
|
|
@ -71,9 +71,7 @@ void NVDRV::QueryEvent(Kernel::HLERequestContext& ctx) {
|
|||
|
||||
IPC::ResponseBuilder rb{ctx, 3, 1};
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
|
||||
const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent("NVDRV::query_event")};
|
||||
rb.PushCopyObjects(event->second);
|
||||
rb.PushCopyObjects(query_event.readable);
|
||||
rb.Push<u32>(0);
|
||||
}
|
||||
|
||||
|
@ -131,8 +129,8 @@ NVDRV::NVDRV(std::shared_ptr<Module> nvdrv, const char* name)
|
|||
RegisterHandlers(functions);
|
||||
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
query_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::OneShot, "NVDRV::query_event");
|
||||
query_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::OneShot,
|
||||
"NVDRV::query_event");
|
||||
}
|
||||
|
||||
NVDRV::~NVDRV() = default;
|
||||
|
|
|
@ -34,7 +34,7 @@ private:
|
|||
|
||||
u64 pid{};
|
||||
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> query_event;
|
||||
Kernel::EventPair query_event;
|
||||
};
|
||||
|
||||
} // namespace Service::Nvidia
|
||||
|
|
|
@ -16,8 +16,8 @@ namespace Service::NVFlinger {
|
|||
|
||||
BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) {
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
buffer_wait_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::Sticky, "BufferQueue NativeHandle");
|
||||
buffer_wait_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Sticky,
|
||||
"BufferQueue NativeHandle");
|
||||
}
|
||||
|
||||
BufferQueue::~BufferQueue() = default;
|
||||
|
@ -31,7 +31,7 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
|
|||
buffer.status = Buffer::Status::Free;
|
||||
|
||||
queue.emplace_back(buffer);
|
||||
buffer_wait_event->Signal();
|
||||
buffer_wait_event.writable->Signal();
|
||||
}
|
||||
|
||||
std::optional<u32> BufferQueue::DequeueBuffer(u32 width, u32 height) {
|
||||
|
@ -90,7 +90,7 @@ void BufferQueue::ReleaseBuffer(u32 slot) {
|
|||
ASSERT(itr->status == Buffer::Status::Acquired);
|
||||
itr->status = Buffer::Status::Free;
|
||||
|
||||
buffer_wait_event->Signal();
|
||||
buffer_wait_event.writable->Signal();
|
||||
}
|
||||
|
||||
u32 BufferQueue::Query(QueryType type) {
|
||||
|
@ -108,13 +108,11 @@ u32 BufferQueue::Query(QueryType type) {
|
|||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> BufferQueue::GetWritableBufferWaitEvent() const {
|
||||
return buffer_wait_event;
|
||||
return buffer_wait_event.writable;
|
||||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::ReadableEvent> BufferQueue::GetBufferWaitEvent() const {
|
||||
const auto& event{
|
||||
Core::System::GetInstance().Kernel().FindNamedEvent("BufferQueue NativeHandle")};
|
||||
return event->second;
|
||||
return buffer_wait_event.readable;
|
||||
}
|
||||
|
||||
} // namespace Service::NVFlinger
|
||||
|
|
|
@ -11,16 +11,12 @@
|
|||
#include "common/math_util.h"
|
||||
#include "common/swap.h"
|
||||
#include "core/hle/kernel/object.h"
|
||||
#include "core/hle/kernel/writable_event.h"
|
||||
|
||||
namespace CoreTiming {
|
||||
struct EventType;
|
||||
}
|
||||
|
||||
namespace Kernel {
|
||||
class ReadableEvent;
|
||||
class WritableEvent;
|
||||
} // namespace Kernel
|
||||
|
||||
namespace Service::NVFlinger {
|
||||
|
||||
struct IGBPBuffer {
|
||||
|
@ -100,7 +96,7 @@ private:
|
|||
u64 layer_id;
|
||||
|
||||
std::vector<Buffer> queue;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> buffer_wait_event;
|
||||
Kernel::EventPair buffer_wait_event;
|
||||
};
|
||||
|
||||
} // namespace Service::NVFlinger
|
||||
|
|
|
@ -87,9 +87,7 @@ u32 NVFlinger::GetBufferQueueId(u64 display_id, u64 layer_id) {
|
|||
}
|
||||
|
||||
Kernel::SharedPtr<Kernel::ReadableEvent> NVFlinger::GetVsyncEvent(u64 display_id) {
|
||||
const auto& event{Core::System::GetInstance().Kernel().FindNamedEvent(
|
||||
fmt::format("Display VSync Event {}", display_id))};
|
||||
return event->second;
|
||||
return GetDisplay(display_id).vsync_event.readable;
|
||||
}
|
||||
|
||||
std::shared_ptr<BufferQueue> NVFlinger::GetBufferQueue(u32 id) const {
|
||||
|
@ -121,7 +119,7 @@ Layer& NVFlinger::GetLayer(u64 display_id, u64 layer_id) {
|
|||
void NVFlinger::Compose() {
|
||||
for (auto& display : displays) {
|
||||
// Trigger vsync for this display at the end of drawing
|
||||
SCOPE_EXIT({ display.vsync_event->Signal(); });
|
||||
SCOPE_EXIT({ display.vsync_event.writable->Signal(); });
|
||||
|
||||
// Don't do anything for displays without layers.
|
||||
if (display.layers.empty())
|
||||
|
@ -168,8 +166,8 @@ Layer::~Layer() = default;
|
|||
|
||||
Display::Display(u64 id, std::string name) : id(id), name(std::move(name)) {
|
||||
auto& kernel = Core::System::GetInstance().Kernel();
|
||||
vsync_event = Kernel::WritableEvent::CreateRegisteredEventPair(
|
||||
kernel, Kernel::ResetType::Pulse, fmt::format("Display VSync Event {}", id));
|
||||
vsync_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Pulse,
|
||||
fmt::format("Display VSync Event {}", id));
|
||||
}
|
||||
|
||||
Display::~Display() = default;
|
||||
|
|
|
@ -45,7 +45,7 @@ struct Display {
|
|||
std::string name;
|
||||
|
||||
std::vector<Layer> layers;
|
||||
Kernel::SharedPtr<Kernel::WritableEvent> vsync_event;
|
||||
Kernel::EventPair vsync_event;
|
||||
};
|
||||
|
||||
class NVFlinger final {
|
||||
|
|
|
@ -10,11 +10,11 @@
|
|||
#include "core/hle/kernel/handle_table.h"
|
||||
#include "core/hle/kernel/mutex.h"
|
||||
#include "core/hle/kernel/process.h"
|
||||
#include "core/hle/kernel/readable_event.h"
|
||||
#include "core/hle/kernel/scheduler.h"
|
||||
#include "core/hle/kernel/thread.h"
|
||||
#include "core/hle/kernel/timer.h"
|
||||
#include "core/hle/kernel/wait_object.h"
|
||||
#include "core/hle/kernel/writable_event.h"
|
||||
#include "core/memory.h"
|
||||
|
||||
WaitTreeItem::WaitTreeItem() = default;
|
||||
|
@ -154,7 +154,7 @@ QString WaitTreeWaitObject::GetText() const {
|
|||
std::unique_ptr<WaitTreeWaitObject> WaitTreeWaitObject::make(const Kernel::WaitObject& object) {
|
||||
switch (object.GetHandleType()) {
|
||||
case Kernel::HandleType::Event:
|
||||
return std::make_unique<WaitTreeEvent>(static_cast<const Kernel::WritableEvent&>(object));
|
||||
return std::make_unique<WaitTreeEvent>(static_cast<const Kernel::ReadableEvent&>(object));
|
||||
case Kernel::HandleType::Timer:
|
||||
return std::make_unique<WaitTreeTimer>(static_cast<const Kernel::Timer&>(object));
|
||||
case Kernel::HandleType::Thread:
|
||||
|
@ -332,7 +332,7 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
|
|||
return list;
|
||||
}
|
||||
|
||||
WaitTreeEvent::WaitTreeEvent(const Kernel::WritableEvent& object) : WaitTreeWaitObject(object) {}
|
||||
WaitTreeEvent::WaitTreeEvent(const Kernel::ReadableEvent& object) : WaitTreeWaitObject(object) {}
|
||||
WaitTreeEvent::~WaitTreeEvent() = default;
|
||||
|
||||
std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeEvent::GetChildren() const {
|
||||
|
@ -341,7 +341,7 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeEvent::GetChildren() const {
|
|||
list.push_back(std::make_unique<WaitTreeText>(
|
||||
tr("reset type = %1")
|
||||
.arg(GetResetTypeQString(
|
||||
static_cast<const Kernel::WritableEvent&>(object).GetResetType()))));
|
||||
static_cast<const Kernel::ReadableEvent&>(object).GetResetType()))));
|
||||
return list;
|
||||
}
|
||||
|
||||
|
|
|
@ -17,8 +17,8 @@
|
|||
class EmuThread;
|
||||
|
||||
namespace Kernel {
|
||||
class ReadableEvent;
|
||||
class WaitObject;
|
||||
class WritableEvent;
|
||||
class Thread;
|
||||
class Timer;
|
||||
} // namespace Kernel
|
||||
|
@ -144,7 +144,7 @@ public:
|
|||
class WaitTreeEvent : public WaitTreeWaitObject {
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit WaitTreeEvent(const Kernel::WritableEvent& object);
|
||||
explicit WaitTreeEvent(const Kernel::ReadableEvent& object);
|
||||
~WaitTreeEvent() override;
|
||||
|
||||
std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override;
|
||||
|
|
Loading…
Reference in a new issue