| Age | Commit message (Collapse) | Author |
|---|
|
|
|
service/am: Supply remaining missing IAudioController functions
|
|
This just acts as a basic setter for a given PID value and performs no
further checking, so we can just store the passed in value.
|
|
All this does is supply a new volume level and a fade time in
nanoseconds for the volume transition to occur within.
|
|
Like the other volume setter, this mainly just sets a data member within
the service, nothing too special.
|
|
This function passes in the desired main applet and library applet
volume levels. We can then just pass those values back within the
relevant volume getter functions, allowing us to unstub those as well.
The initial values for the library and main applet volumes differ. The
main applet volume is 0.25 by default, while the library applet volume
is initialized to 1.0 by default in the services themselves.
|
|
kernel/thread: Amend conditional test and assignment within UpdatePriority()
|
|
core: Move PageTable struct into Common.
|
|
ipc_helpers: Allow pushing and popping floating-point values
|
|
|
|
Certain values that are passed through the IPC buffer are actually
floating point values, not solely integral values.
|
|
This was intended to be removed in
51d7f6bffcc0498a47abc7de27bf0906fc523dae, but I guess I forgot to
actually save the file like a dingus.
|
|
kernel/thread: Remove WaitCurrentThread_Sleep() and ExitCurrentThread()
|
|
Puts the operation on global state in the same places as the rest of the
svc calls.
|
|
Rather than make a global accessor for this sort of thing. We can make
it a part of the thread interface itself. This allows getting rid of a
hidden global accessor in the kernel code.
|
|
Aims to disambiguate why each priority instance exists a little bit.
While we're at it, also add an explanatory comment to UpdatePriority().
|
|
|
|
This condition was checking against the nominal thread priority, whereas
the kernel itself checks against the current priority instead. We were
also assigning the nominal priority, when we should be assigning
current_priority, which takes priority inheritance into account.
This can lead to the incorrect priority being assigned to a thread.
Given we recursively update the relevant threads, we don't need to go
through the whole mutex waiter list. This matches what the kernel does
as well (only accessing the first entry within the waiting list).
|
|
The kernel keeps the internal waiting list ordered by priority. This is
trivial to do with std::find_if followed by an insertion.
|
|
|
|
Removes the use of global system accessors, and instead uses the
explicit interface provided.
|
|
Makes it an instantiable class like it is in the actual kernel. This
will also allow removing reliance on global accessors in a following
change, now that we can encapsulate a reference to the system instance
in the class.
|
|
kernel/process: Remove use of global system accessors
|
|
kernel/server_port: Make data members private
|
|
core/hle/result: Tidy up the base error code result header.
|
|
service/vi: Unstub GetDisplayService
|
|
Similarly, like svcMapTransferMemory, we can also implement
svcUnmapTransferMemory fairly trivially as well.
|
|
Now that transfer memory handling is separated from shared memory, we
can implement svcMapTransferMemory pretty trivially.
|
|
Within the kernel, shared memory and transfer memory facilities exist as
completely different kernel objects. They also have different validity
checking as well. Therefore, we shouldn't be treating the two as the
same kind of memory.
They also differ in terms of their behavioral aspect as well. Shared
memory is intended for sharing memory between processes, while transfer
memory is intended to be for transferring memory to other processes.
This breaks out the handling for transfer memory into its own class and
treats it as its own kernel object. This is also important when we
consider resource limits as well. Particularly because transfer memory
is limited by the resource limit value set for it.
While we currently don't handle resource limit testing against objects
yet (but we do allow setting them), this will make implementing that
behavior much easier in the future, as we don't need to distinguish
between shared memory and transfer memory allocations in the same place.
|
|
Now that we pass in a reference to the system instance, we can utilize
it to eliminate the global accessors in Process-related code.
|
|
kernel: Make the address arbiter instance per-process
|
|
|
|
With this, all kernel objects finally have all of their data members
behind an interface, making it nicer to reason about interactions with
other code (as external code no longer has the freedom to totally alter
internals and potentially messing up invariants).
|
|
After doing a little more reading up on the Opus codec, it turns out
that the multistream API that is part of libopus can handle regular
packets. Regular packets are just a degenerate case of multistream Opus
packets, and all that's necessary is to pass the number of streams as 1
and provide a basic channel mapping, then everything works fine for
that case.
This allows us to get rid of the need to use both APIs in the future
when implementing multistream variants in a follow-up PR, greatly
simplifying the code that needs to be written.
|
|
|
|
|
|
operator
Previously this was required, as BitField wasn't trivially copyable.
BitField has since been made trivially copyable, so now this isn't
required anymore.
|
|
Gets rid of another holdover from Citra, and describes the OS on the
Switch instead.
|
|
Now that the final stray ErrorDescription member was relocated, we can
finally remove it and its relevant constructor in the ResultCode union.
|
|
Relocates the error code to where it's most related, similar to how all
the other error codes are. Previously we were including a non-generic
error in the main result code header.
|
|
These can just be passed regularly, now that we use fmt instead of our
old logging system.
While we're at it, make the parameters to MakeFunctionString
std::string_views.
|
|
service/audio/hwopus: Move decoder state to its own class
|
|
kernel/scheduler: Pass in system instance in constructor
|
|
Uses the synthesized system archive 9 (SystemVersion) and reports v5.1.0-0.0
|
|
kernel/hle_ipc: Convert std::shared_ptr IPC header instances to std::optional
|
|
There's no real need to use a shared lifetime here, since we don't
actually expose them to anything else. This is also kind of an
unnecessary use of the heap given the objects themselves are so small;
small enough, in fact that changing over to optionals actually reduces
the overall size of the HLERequestContext struct (818 bytes to 808
bytes).
|
|
Now that we have the address arbiter extracted to its own class, we can
fix an innaccuracy with the kernel. Said inaccuracy being that there
isn't only one address arbiter. Each process instance contains its own
AddressArbiter instance in the actual kernel.
This fixes that and gets rid of another long-standing issue that could
arise when attempting to create more than one process.
|
|
Similar to how WaitForAddress was isolated to its own function, we can
also move the necessary conditional checking into the address arbiter
class itself, allowing us to hide the implementation details of it from
public use.
|
|
Rather than let the service call itself work out which function is the
proper one to call, we can make that a behavior of the arbiter itself,
so we don't need to directly expose those implementation details.
|
|
kernel/shared_memory: Get rid of the use of global accessor functions within Create()
|
