Mirror-bot/AnyPS5
1
0 Fork 0
mirror of https://github.com/boykopovar/AnyPS5.git synced 2026-10-27 00:28:14 +00:00
Code Issues Projects Releases Activity

refactor(sdk): add canonical headers for remaining libraries

Browse Source
This commit is contained in:
boykopovar committed 2026-10-24 23:17:42 +03:00
1 parent 35cf8d56cd
commit f38d29fd08
1491 files changed
+19124 -12458
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

core/libs/prx/libSceAbstractLocal/libSceAbstractLocal.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAbstractStorage/libSceAbstractStorage.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAbstractTcs/libSceAbstractTcs.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAbstractTwitter/libSceAbstractTwitter.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAbstractYoutube/libSceAbstractYoutube.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAc3Enc/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAc3Enc/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAc3Enc/include/Api.hpp
+15
View File
@@ -0,0 +1,15 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAc3EncCreateEncoder();
int APS5_VABI sceAc3EncDeleteEncoder();
int APS5_VABI sceAc3EncEncode();
int APS5_VABI sceAc3EncEncodeAsync();
int APS5_VABI sceAc3EncFlush();
int APS5_VABI sceAc3EncIsEncoding();
int APS5_VABI sceAc3EncWaitEncode();
}
core/libs/prx/libSceAc3Enc/libSceAc3Enc.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAc3Enc/include/Api.hpp"
core/libs/prx/libSceAcm/Export.cpp
+1 -1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAcm/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include <cstring>
@@ -217,7 +218,6 @@ int APS5_VABI sceAcm_IFFT() {
return 0;
}
int APS5_VABI sceAcmBatchJobNotification() {
NotImplemented_nid_no_patch(__func__);
return 0;
core/libs/prx/libSceAcm/include/Api.hpp
+20
View File
@@ -0,0 +1,20 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAcmBatchStartBuffer(AcmContextId context, const void* batchCommands, size_t batchSize, AcmBatchError* batchError, AcmBatchId* batch);
int APS5_VABI sceAcmBatchStartBuffers(AcmContextId context, uint32_t batchInfoCount, const AcmBatchInfo* const batch_info[], AcmBatchError* batchError, AcmBatchId* batch);
int APS5_VABI sceAcmBatchWait(AcmContextId context, AcmBatchId batch, uint32_t timeout);
int APS5_VABI sceAcmContextCreate(AcmContextId* context);
int APS5_VABI sceAcmContextDestroy(AcmContextId context);
int APS5_VABI sceAcm_ConvReverb_SharedInput(AcmBatchInfo* batch, std::uint32_t mode, AcmReverbInput* input, std::uint32_t outputCount, const AcmReverbFilter* const* filters, const float* gains, const AcmReverbOutput* const* outputs);
int APS5_VABI sceAcm_FFT(AcmBatchInfo* batch, std::int32_t transformSize, std::uint32_t transformCount, std::int32_t inputFormat, const void* const* inputs, std::int32_t outputFormat, void* const* outputs, std::int32_t flags);
int APS5_VABI sceAcm_Panner(AcmBatchInfo* batch, std::uint32_t sourceCount, const void* const* sources, std::uint32_t sourceMode, std::uint32_t outputMode, std::uint32_t channelCount, const void* const* sourceParameters, const void* const* sourceMatrices, const void* const* inputChannels, void* const* outputChannels);
int APS5_VABI sceAcmBatchJobPriority(AcmBatchInfo* batch, std::uint32_t priority);
int APS5_VABI sceAcm_ConvReverb_SharedIr();
int APS5_VABI sceAcm_IFFT();
int APS5_VABI sceAcmBatchJobNotification();
}
core/libs/prx/libSceAcm/libSceAcm.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAcm/include/Api.hpp"
core/libs/prx/libSceAgcDriver/Execution/src/Pm4.cpp
+1 -3
View File
@@ -1,3 +1,4 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libSceAgcDriver/Execution/include/Pm4.hpp"
#include "prx/libSceAgcDriver/Execution/include/GuestMemory.hpp"
#include "prx/libc/include/General.hpp"
@@ -13,8 +14,6 @@
#include <stdexcept>
#include <string>
extern "C" void* APS5_VABI mmap_nid_postfix(void* address, std::size_t length, int protection, int flags, int descriptor, std::int64_t offset) noexcept;
namespace AgcDriver::Pm4 {
std::uint64_t GdsAddress() {
@@ -115,7 +114,6 @@ std::vector<std::byte> copySource(std::uint64_t source, std::size_t bytes, bool
return data;
}
bool gdsRange(std::uint64_t offset, std::size_t bytes) {
return offset <= GdsBytes && bytes <= GdsBytes - offset;
}
core/libs/prx/libSceAgcDriver/tests/Graphics.cpp
+2 -3
View File
@@ -1,3 +1,4 @@
#include "prx/libc/include/Api.hpp"
#include "BdaTests.hpp"
#include "GraphicsTests.hpp"
#include "prx/libSceAgcDriver/Execution/include/GuestMemory.hpp"
@@ -64,8 +65,6 @@
#include <thread>
#include <vector>
extern "C" std::terminate_handler APS5_VABI _ZSt13set_terminatePFvvE_nid_postfix(std::terminate_handler handler);
namespace {
using AgcDriver::Graphics::Require;
@@ -5980,6 +5979,7 @@ void descriptorPoolResetFailureTest() {
});
cache.Free(allocation);
_ZSt13set_terminatePFvvE_nid_postfix(previous);
}
void pushConstantTests() {
@@ -10962,7 +10962,6 @@ void validationTests() {
}
}
}
bool recompilesDebugBranch(std::uint32_t opcode) {
core/libs/prx/libSceAgcDriver/tests/Pm4.cpp
+1 -2
View File
@@ -1,3 +1,4 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libSceAgcDriver/Execution/include/Pm4.hpp"
#include "prx/libSceAgcDriver/Execution/include/GuestMemory.hpp"
#include "prx/libSceAgcDriver/Execution/include/Driver.hpp"
@@ -40,8 +41,6 @@
#include <unistd.h>
#endif
extern "C" int APS5_VABI sceKernelAvailableFlexibleMemorySize(size_t* size);
namespace {
void check(bool condition, const char* reason) {
core/libs/prx/libSceAgcDriver/tests/Recorder.cpp
+10 -18
View File
@@ -1,3 +1,4 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libSceAgc/Command/include/Packet.hpp"
#include "prx/libSceAgcDriver/Execution/include/PipelineLinkOptimization.hpp"
#include "Triangle_frag_spv.h"
@@ -79,14 +80,6 @@
namespace {
extern "C" {
int APS5_VABI sceKernelAllocateDirectMemory(std::int64_t, std::int64_t, std::size_t, std::size_t, int, std::int64_t*);
int APS5_VABI sceKernelMapDirectMemory(void**, std::size_t, int, int, std::int64_t, std::size_t);
int APS5_VABI sceKernelReleaseDirectMemory(std::int64_t, std::size_t);
int APS5_VABI sceKernelMunmap(void*, std::size_t);
int APS5_VABI sceKernelMprotect(const void*, std::size_t, int);
}
using namespace AgcDriver::Graphics;
using AgcDriver::GuestMemory::GpuMutex;
@@ -1331,7 +1324,7 @@ void directCompletionLabelTests(Recorder& recorder) {
std::int64_t physical = -1;
~Release() {
recorder.Sync();
if (mapping != nullptr) sceKernelMunmap(mapping, size);
if (mapping != nullptr) sceKernelMunmap(reinterpret_cast<std::uint64_t>(mapping), size);
if (physical >= 0) sceKernelReleaseDirectMemory(physical, size);
}
} release{recorder};
@@ -2694,8 +2687,8 @@ void secondMappingImportTests(const Device& device) {
void* alias = nullptr;
std::int64_t physical = -1;
~Release() {
if (alias != nullptr) sceKernelMunmap(alias, page);
if (mapping != nullptr) sceKernelMunmap(mapping, bytes);
if (alias != nullptr) sceKernelMunmap(reinterpret_cast<std::uint64_t>(alias), page);
if (mapping != nullptr) sceKernelMunmap(reinterpret_cast<std::uint64_t>(mapping), bytes);
if (physical >= 0) sceKernelReleaseDirectMemory(physical, bytes);
}
} release;
@@ -2766,7 +2759,7 @@ int reimportBench(const Device& device) {
void* mapping = nullptr;
std::int64_t physical = -1;
~Release() {
if (mapping != nullptr) sceKernelMunmap(mapping, bytes);
if (mapping != nullptr) sceKernelMunmap(reinterpret_cast<std::uint64_t>(mapping), bytes);
if (physical >= 0) sceKernelReleaseDirectMemory(physical, bytes);
}
};
@@ -2916,8 +2909,8 @@ int hostImportCutTests(const Device& device) {
std::size_t holeBytes = 0;
~Backing() {
auto* memory = static_cast<std::byte*>(mapping);
if (memory != nullptr && hole != 0) sceKernelMunmap(memory, hole);
if (memory != nullptr && hole + holeBytes < bytes) sceKernelMunmap(memory + hole + holeBytes, bytes - hole - holeBytes);
if (memory != nullptr && hole != 0) sceKernelMunmap(reinterpret_cast<std::uint64_t>(memory), hole);
if (memory != nullptr && hole + holeBytes < bytes) sceKernelMunmap(reinterpret_cast<std::uint64_t>(memory + hole + holeBytes), bytes - hole - holeBytes);
if (physical >= 0) sceKernelReleaseDirectMemory(physical, bytes);
}
};
@@ -2946,7 +2939,7 @@ int hostImportCutTests(const Device& device) {
auto* cut = memory + test.offset;
gpu.unlock();
if (test.unmap) {
Require(sceKernelMunmap(cut, test.length) == 0, name + ": the unmap failed");
Require(sceKernelMunmap(reinterpret_cast<std::uint64_t>(cut), test.length) == 0, name + ": the unmap failed");
backing.hole = test.offset;
backing.holeBytes = test.length;
} else {
@@ -2996,7 +2989,7 @@ int hostImportCutTests(const Device& device) {
Require(whole != nullptr && whole->base == address && whole->bytes == bytes && whole->alias == nullptr && !whole->unwatched, name + ": the range was not imported whole, settled and watched");
gpu.unlock();
Require(sceKernelMprotect(memory, run, 0x03) == 0, name + ": the protection of the head failed");
Require(sceKernelMunmap(memory + run, bytes - run) == 0, name + ": the unmap of the kept side failed");
Require(sceKernelMunmap(reinterpret_cast<std::uint64_t>(memory + run), bytes - run) == 0, name + ": the unmap of the kept side failed");
backing.hole = run;
backing.holeBytes = bytes - run;
void* again = memory + run;
@@ -6944,7 +6937,6 @@ void refreshProofTests(const Device& device, Recorder& recorder) {
recorder.Sync();
}
void unchangedCpuStampTests(const Device& device, Recorder& recorder) {
const auto& base = device.GetContext();
constexpr std::uint32_t side = 256;
@@ -7094,7 +7086,7 @@ void keptUnitSettleTests(const Device& device, Recorder& recorder) {
return;
}
if (direct) {
if (block != nullptr) sceKernelMunmap(block, surfaceBytes);
if (block != nullptr) sceKernelMunmap(reinterpret_cast<std::uint64_t>(block), surfaceBytes);
if (physical >= 0) sceKernelReleaseDirectMemory(physical, surfaceBytes);
return;
}
core/libs/prx/libSceAgcDriver/tests/SharedWrites.cpp
+5 -11
View File
@@ -1,3 +1,4 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libSceAgcDriver/Execution/include/GuestMemory.hpp"
#include "prx/libc/include/GuestWriteWatch.hpp"
#include "prx/libc/include/GuestArena.hpp"
@@ -17,14 +18,6 @@
#include <sys/resource.h>
#endif
extern "C" {
int APS5_VABI sceKernelAllocateDirectMemory(std::int64_t, std::int64_t, std::size_t, std::size_t, int, std::int64_t*);
int APS5_VABI sceKernelMapDirectMemory(void**, std::size_t, int, int, std::int64_t, std::size_t);
int APS5_VABI sceKernelReleaseDirectMemory(std::int64_t, std::size_t);
int APS5_VABI sceKernelMunmap(void*, std::size_t);
int APS5_VABI sceKernelMprotect(const void*, std::size_t, int);
}
namespace {
using namespace AgcDriver::GuestMemory;
void require(bool condition, const char* reason) { if (!condition) throw std::runtime_error(reason); }
@@ -36,13 +29,14 @@ struct Mapping {
require(sceKernelAllocateDirectMemory(0, 0x10000000000ll, size, 65536, 3, &physical) == 0, "allocate direct memory failed");
if (sceKernelMapDirectMemory(&data, size, 3, 0, physical, 65536) != 0) {
sceKernelReleaseDirectMemory(physical, size);
throw std::runtime_error("map direct memory failed");
}
}
Mapping(const Mapping&) = delete;
Mapping& operator=(const Mapping&) = delete;
~Mapping() {
if (data != nullptr) sceKernelMunmap(data, size);
if (data != nullptr) sceKernelMunmap(reinterpret_cast<std::uint64_t>(data), size);
if (physical >= 0) sceKernelReleaseDirectMemory(physical, size);
}
std::uint64_t Address() const { return reinterpret_cast<std::uint64_t>(data); }
@@ -180,7 +174,7 @@ void partialCollect() {
require(collect(alias, 0, mapping.size, 4, true) == std::vector<std::size_t>{page, page * 2}, "writes to two pages were not reported apart");
require(collect(mapping.data, 0, mapping.size, 4, true) == std::vector<std::size_t>{page, page * 2}, "writes to two pages were not reported for their own view");
require(collect(mapping.data, 0, mapping.size, 4, false).empty() && collect(alias, 0, mapping.size, 4, false).empty(), "page tracking did not settle");
require(sceKernelMunmap(alias, mapping.size) == 0, "partial collect alias unmap failed");
require(sceKernelMunmap(reinterpret_cast<std::uint64_t>(alias), mapping.size) == 0, "partial collect alias unmap failed");
#endif
std::cout << "Partial shared write collection tests passed\n";
}
@@ -260,7 +254,7 @@ void run() {
require(bytes[0] == saved, "failed shared write changed its prefix");
#endif
require(sceKernelMapDirectMemory(&middle, part, 3, 0x10, mapping.physical + part, part) == 0, "original backing restore failed");
require(sceKernelMunmap(originalAlias, part) == 0, "alias unmap failed");
require(sceKernelMunmap(reinterpret_cast<std::uint64_t>(originalAlias), part) == 0, "alias unmap failed");
}
std::vector<std::thread> threads;
for (unsigned i = 0; i < 8; ++i) threads.emplace_back([&, i] {
core/libs/prx/libSceAgcDriver/tests/Submit.cpp
+1 -3
View File
@@ -1,3 +1,4 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libSceAgcDriver/Execution/include/Driver.hpp"
#include "execution/VulkanTestDevice.hpp"
#include "prx/libSceAgcDriver/Execution/include/QueueState.hpp"
@@ -31,9 +32,6 @@
#include <windows.h>
#endif
extern "C" int APS5_VABI sceKernelCreateEqueue(KernelEqueue* eq, const char* name);
extern "C" int APS5_VABI sceKernelDeleteEqueue(KernelEqueue eq);
static_assert(sizeof(Packet) == 16);
static_assert(offsetof(Packet, addr) == 0);
static_assert(offsetof(Packet, dw_num) == 8);
core/libs/prx/libSceAgcDriver/tests/execution/GpuMapOnFiber.cpp
+2 -9
View File
@@ -1,3 +1,4 @@
#include "prx/libSceFiber/include/Api.hpp"
#include "prx/libSceAgcDriver/Execution/include/Driver/Driver.hpp"
#include "prx/libc/include/GuestAllocations.hpp"
#include "prx/libc/include/general/VabiMacros.hpp"
@@ -17,15 +18,6 @@
#include <iostream>
#include <string>
using GuestFiberEntry = void (APS5_VABI*)(std::uint64_t, std::uint64_t);
extern "C" {
std::int32_t APS5_VABI _sceFiberInitializeImpl_nid_postfix(FiberObject*, const char*, GuestFiberEntry, std::uint64_t, void*, std::uint64_t, const void*, std::uint32_t);
std::int32_t APS5_VABI sceFiberFinalize(FiberObject*);
std::int32_t APS5_VABI sceFiberRun_nid_postfix(FiberObject*, std::uint64_t, std::uint64_t*);
std::int32_t APS5_VABI sceFiberReturnToThread(std::uint64_t, std::uint64_t*);
}
namespace {
using AgcDriver::DriverDetail::Driver;
@@ -77,6 +69,7 @@ void MapForGpu() {
void APS5_VABI MapOnFiber(std::uint64_t, std::uint64_t) {
MapForGpu();
sceFiberReturnToThread(0, nullptr);
}
void ReleaseMapping() {
core/libs/prx/libSceAgcDriver/tests/execution/GuestMemoryLifetime.cpp
+4 -13
View File
@@ -1,3 +1,5 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libc/include/Api.hpp"
#include "prx/libSceAgcDriver/Execution/include/GuestMemory.hpp"
#include "prx/libSceAgcDriver/Execution/include/VulkanDevice.hpp"
#include "prx/libSceAgcDriver/Graphics/include/GuestBufferMemory.hpp"
@@ -17,19 +19,6 @@
#include <stdexcept>
#include <string_view>
extern "C" {
void* APS5_VABI mmap_nid_postfix(void*, std::size_t, int, int, int, std::int64_t) noexcept;
int APS5_VABI munmap_nid_postfix(void*, std::size_t) noexcept;
int APS5_VABI mprotect_nid_postfix(void*, std::size_t, int) noexcept;
void* APS5_VABI memalign_nid_postfix(std::size_t, std::size_t);
void* APS5_VABI realloc_nid_postfix(void*, std::size_t);
void APS5_VABI free_nid_postfix(void*);
int APS5_VABI sceKernelMapFlexibleMemory(void**, std::size_t, int, int);
int APS5_VABI sceKernelAllocateDirectMemory(std::int64_t, std::int64_t, std::size_t, std::size_t, int, std::int64_t*);
int APS5_VABI sceKernelMapDirectMemory(void**, std::size_t, int, int, std::int64_t, std::size_t);
int APS5_VABI sceKernelReleaseDirectMemory(std::int64_t, std::size_t);
}
namespace {
constexpr std::size_t BlockBytes = 65536;
@@ -141,12 +130,14 @@ void CheckHeap(AgcDriver::VulkanDevice& device) {
Require(!Imported(device, allocation), "host import survived guest realloc");
CheckPattern(replacement);
free_nid_postfix(replacement);
for (int iteration = 0; iteration < 3; ++iteration) {
allocation = memalign_nid_postfix(BlockBytes, BlockBytes);
Require(allocation != nullptr, "guest heap reuse allocation failed");
std::memset(allocation, 0, BlockBytes);
Fill(device, allocation);
free_nid_postfix(allocation);
Require(!Imported(device, allocation), "host import survived guest free or heap cache eviction");
}
}
core/libs/prx/libSceAgcDriver/tests/execution/JobManagerCompute.cpp
+7 -61
View File
@@ -1,3 +1,5 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libSceJobManager/include/Api.hpp"
#include "VulkanTestDevice.hpp"
#include "SceTypes.hpp"
#include "prx/libc/include/GuestArena.hpp"
@@ -17,62 +19,6 @@
extern "C" void AgcDriverShutdown_nid_postfix();
struct MemorySizeQueryParams {
std::uint32_t version;
std::uint32_t workers;
std::uint32_t sequences;
std::uint32_t invocations;
std::uint32_t dispatches;
std::uint32_t syncPoints;
std::uint32_t waits;
std::uint32_t computeSequences;
std::uint64_t computeQueueMask;
};
struct ConfigParams {
std::uint32_t version;
std::uint32_t threadFlags;
std::uint32_t stackSize;
std::uint32_t priority;
const char* threadName;
std::uint32_t spinMicroseconds;
std::uint32_t computeAffinity;
std::uint32_t computePriority;
std::uint32_t reserved;
};
using JobEntry = void (APS5_VABI*)(void*, std::uint32_t);
struct Sequence {
APS5_VABI virtual int Dispatch(JobEntry, void*, std::uint32_t, const char*) = 0;
APS5_VABI virtual int SyncPoint() = 0;
APS5_VABI virtual int Wait() = 0;
APS5_VABI virtual void CompleteDestructor() = 0;
APS5_VABI virtual void DeletingDestructor() = 0;
APS5_VABI virtual int DispatchCompute(const void*, void*, std::int32_t, std::int32_t, std::int32_t, const char*) = 0;
APS5_VABI virtual int DispatchComputeIndirect(const void*, void*, const void*, const char*) = 0;
};
struct SequenceFactory {
APS5_VABI virtual int Create(Sequence**, std::uint32_t, std::uint32_t, std::uint32_t, std::uint32_t, const char*) = 0;
APS5_VABI virtual int Destroy(Sequence*) = 0;
APS5_VABI virtual void CompleteDestructor() = 0;
APS5_VABI virtual void DeletingDestructor() = 0;
APS5_VABI virtual int CreateCompute(Sequence**, std::uint32_t, std::uint32_t, std::uint32_t, std::uint32_t, const char*) = 0;
APS5_VABI virtual int DestroyCompute(Sequence*) = 0;
};
extern "C" {
int APS5_VABI sceKernelAllocateDirectMemory(std::int64_t, std::int64_t, std::size_t, std::size_t, int, std::int64_t*);
int APS5_VABI sceKernelMapDirectMemory(void**, std::size_t, int, int, std::int64_t, std::size_t);
int APS5_VABI sceKernelReleaseDirectMemory(std::int64_t, std::size_t);
void APS5_VABI _ZN3sce3Job10JobManagerC1Ev(void*);
std::uint64_t APS5_VABI _ZN3sce3Job10JobManager27calculateRequiredMemorySizeEPKNS1_21MemorySizeQueryParamsE(const MemorySizeQueryParams*);
int APS5_VABI _ZN3sce3Job10JobManager10initializeEPvmjjjmPKNS1_12ConfigParamsE(void*, void*, std::uint64_t, std::uint32_t, std::uint32_t, std::uint32_t, std::uint64_t, const ConfigParams*);
int APS5_VABI _ZN3sce3Job10JobManager8shutdownEv(void*);
SequenceFactory* APS5_VABI _ZN3sce3Job10JobManager34getUnifiedSequenceFactoryInterfaceENS1_8PriorityE(void*, std::uint32_t);
}
#define Construct _ZN3sce3Job10JobManagerC1Ev
#define RequiredSize _ZN3sce3Job10JobManager27calculateRequiredMemorySizeEPKNS1_21MemorySizeQueryParamsE
#define Initialize _ZN3sce3Job10JobManager10initializeEPvmjjjmPKNS1_12ConfigParamsE
@@ -171,9 +117,9 @@ void RunCase() {
Require(Initialize(manager, memory, size, 2, 1, 1, 2, &wideAffinity) == InvalidArgument, "a handler affinity beyond 13 cores was accepted");
Require(Initialize(manager, memory, size, 2, 1, 0xffffffffu, 2, nullptr) == InvalidArgument, "a sequence count that wraps was accepted");
Require(Initialize(manager, memory, size, 2, 1, 1, 2, nullptr) == 0, "initialize with one compute sequence failed");
SequenceFactory* factory = Factories(manager, 0);
Sequence* sequence = nullptr;
Sequence* other = nullptr;
ISequenceFactory* factory = Factories(manager, 0);
ISequence* sequence = nullptr;
ISequence* other = nullptr;
Require(factory->CreateCompute(&sequence, 100, 4, 4, 2, "compute") == 0, "the compute sequence was not created");
Require(factory->CreateCompute(&other, 1, 1, 1, 1, "second") == NoneFree, "a second compute sequence was created");
Require(factory->Create(&other, 1, 1, 1, 1, "cpu") == 0, "the CPU sequence was not created");
@@ -260,7 +206,7 @@ void CapacityCase() {
Construct(manager);
Require(Initialize(manager, memory, size, 1, 0, 1, 1, nullptr) == 0, "capacity manager initialization failed");
auto* factory = Factories(manager, 0);
Sequence* sequence = nullptr;
ISequence* sequence = nullptr;
Require(factory->CreateCompute(&sequence, 0, 2, 0, 1, nullptr) == 0, "capacity sequence creation failed");
for (std::uint32_t round = 0; round < 2; ++round) {
Value[0] = 0xabcd0000u + round;
@@ -306,7 +252,7 @@ void StorageCase(bool directMemory) {
Construct(manager);
Require(Initialize(manager, memory, size, 2, 0, 2, mask, nullptr) == 0, "storage manager initialization failed");
auto* factory = Factories(manager, 0);
std::array<Sequence*, 2> sequences{};
std::array<ISequence*, 2> sequences{};
for (auto& sequence : sequences) Require(factory->CreateCompute(&sequence, 0, 16, 4, 2, nullptr) == 0, "storage sequence creation failed");
for (std::uint32_t round = 0; round < 3; ++round) {
for (auto* sequence : sequences) {
core/libs/prx/libSceAgcDriver/tests/execution/QueueZeroLateInterrupt.cpp
+1 -3
View File
@@ -1,3 +1,4 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libSceAgcDriver/Execution/include/Driver.hpp"
#include "prx/libSceAgcDriver/Execution/include/Driver/Draw/DrawPipeline.hpp"
#include "prx/libSceAgcDriver/Execution/include/Driver/Synchronization/SynchronizationStatistics.hpp"
@@ -27,9 +28,6 @@
#include <thread>
#include <vector>
extern "C" int APS5_VABI sceKernelCreateEqueue(KernelEqueue* eq, const char* name);
extern "C" int APS5_VABI sceKernelDeleteEqueue(KernelEqueue eq);
namespace {
constexpr std::uint32_t Lanes = 32;
core/libs/prx/libSceAgcDriver/tests/execution/StorageFileWrite.cpp
+4 -22
View File
@@ -1,3 +1,6 @@
#include "prx/libkernel/include/Api.hpp"
#include "prx/libkernel/File/include/File.hpp"
#include "prx/libc/include/Api.hpp"
#include "prx/libSceAgcDriver/Execution/include/Driver.hpp"
#include "prx/libSceAgcDriver/Execution/include/GuestMemory.hpp"
#include "prx/libSceAgcDriver/Graphics/include/Draw.hpp"
@@ -35,27 +38,6 @@
#endif
class FileStream;
struct GuestIovec { void* base; std::size_t length; };
extern "C" {
int APS5_VABI sceKernelOpen(const char*, int, std::uint16_t);
int APS5_VABI sceKernelClose(int);
std::int64_t APS5_VABI sceKernelWrite(int, const void*, std::size_t);
std::int64_t APS5_VABI sceKernelPwrite(int, const void*, std::size_t, std::int64_t);
std::int64_t APS5_VABI sceKernelWritev(int, const GuestIovec*, int);
std::int64_t APS5_VABI sceKernelPwritev(int, const GuestIovec*, int, std::int64_t);
std::int64_t APS5_VABI write_nid_postfix(int, const char*, std::int64_t);
std::int64_t APS5_VABI _write_nid_postfix(int, const void*, std::size_t);
std::int64_t APS5_VABI pwrite_nid_disambig1_nid_postfix(int, const void*, std::size_t, std::int64_t);
std::int64_t APS5_VABI writev_nid_postfix(int, const GuestIovec*, int);
std::int64_t APS5_VABI pwritev_nid_postfix(int, const GuestIovec*, int, std::int64_t);
int APS5_VABI sceKernelAioSubmitWriteCommands(KernelAioRwRequest*, std::int32_t, std::int32_t, std::int32_t*);
int APS5_VABI sceKernelAioSubmitWriteCommandsMultiple(KernelAioRwRequest*, std::int32_t, std::int32_t, std::int32_t*);
int APS5_VABI sceKernelAioDeleteRequest(std::int32_t, std::int32_t*);
FileStream* APS5_VABI fopen_nid_postfix(const char*, const char*);
std::size_t APS5_VABI fwrite_nid_postfix(const void*, std::size_t, std::size_t, FileStream*);
int APS5_VABI fclose_nid_postfix(FileStream*);
}
namespace {
@@ -192,7 +174,7 @@ bool CheckWrite(Api api, const char* name, GuestSurface& surface, GuestSurface&
const auto hold = ProduceHeld(surface, unrelated);
OutputFile file;
auto* source = surface.Data() + SourceOffset;
const std::array<GuestIovec, 4> vectors{{{source, 111}, {nullptr, 0}, {source + 111, 65537}, {source + 65648, TransferBytes - 65648}}};
const std::array<KernelIovec, 4> vectors{{{source, 111}, {nullptr, 0}, {source + 111, 65537}, {source + 65648, TransferBytes - 65648}}};
const bool positioned = api == Api::Pwrite || api == Api::PosixPwrite || api == Api::Pwritev || api == Api::PosixPwritev || api == Api::Aio || api == Api::AioMultiple;
if (api == Api::Fwrite) {
auto* stream = fopen_nid_postfix(file.Name().c_str(), "wb");
core/libs/prx/libSceAgcResourceRegistration/libSceAgcResourceRegistration.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAgcVsh/Export.cpp
+150
View File
@@ -1,3 +1,153 @@
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include "prx/libSceAgcVsh/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAgcVsh/include/Api.hpp
+158
View File
@@ -0,0 +1,158 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAgcDcbCopyData_nid_no_patch(void);
int APS5_VABI sceAgcBranchPatchSetElseTarget_nid_no_patch(void);
int APS5_VABI sceAgcCbSetShRegistersDirect_nid_no_patch(void);
int APS5_VABI sceAgcCreateShader_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetNumInstancesGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetUcRegisterDirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexIndirectMultiGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbAtomicGdsGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbCopyDataGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbWaitUntilSafeForRendering_nid_no_patch(void);
int APS5_VABI sceAgcAsyncCondExecPatchSetEnd_nid_no_patch(void);
int APS5_VABI sceAgcDcbDmaDataGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetUcRegistersIndirect_nid_no_patch(void);
int APS5_VABI sceAgcGetRegisterDefaults2_nid_no_patch(void);
int APS5_VABI sceAgcCbReleaseMem_nid_no_patch(void);
int APS5_VABI sceAgcCondExecPatchSetEnd_nid_no_patch(void);
int APS5_VABI sceAgcDcbAtomicGds_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetCxRegistersIndirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcCbSetUcRegisterRangeDirect_nid_no_patch(void);
int APS5_VABI sceAgcDcbEventWrite_nid_no_patch(void);
int APS5_VABI sceAgcDcbWriteData_nid_no_patch(void);
int APS5_VABI sceAgcSetUcRegIndirectPatchSetAddress_nid_no_patch(void);
int APS5_VABI sceAgcCbCondWriteGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbQueueEndOfShaderActionGetSize_nid_no_patch(void);
int APS5_VABI sceAgcGetPacketSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbAcquireMem_nid_no_patch(void);
int APS5_VABI sceAgcAcbEventWriteGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetIndexIndirectArgs_nid_no_patch(void);
int APS5_VABI sceAgcAcbDmaData_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexIndirect_nid_no_patch(void);
int APS5_VABI sceAgcDcbPrimeUtcl2GetSize_nid_no_patch(void);
int APS5_VABI sceAgcAsyncCondExecPatchSetCommandAddress_nid_no_patch(void);
int APS5_VABI sceAgcAcbAcquireMemGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetIndexIndirectArgsGetSize_nid_no_patch(void);
int APS5_VABI sceAgcCreateInterpolantMapping_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexIndirectMulti_nid_no_patch(void);
int APS5_VABI sceAgcDcbEventWriteGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetUcRegisterDirect_nid_no_patch(void);
int APS5_VABI sceAgcQueueEndOfPipeActionPatchAddress_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndirectMultiGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetBaseDrawIndirectArgsGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetNumInstances_nid_no_patch(void);
int APS5_VABI sceAgcDcbWaitOnAddressGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbAtomicGds_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetBoolPredicationEnableGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbAtomicMemGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetCfRegisterRangeDirect_nid_no_patch(void);
int APS5_VABI sceAgcDcbCondExecGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexMultiInstanced_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetCxRegistersIndirect_nid_no_patch(void);
int APS5_VABI sceAgcCbSetShRegistersDirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcCondExecPatchSetCommandAddress_nid_no_patch(void);
int APS5_VABI sceAgcRewindPatchSetRewindState_nid_no_patch(void);
int APS5_VABI sceAgcQueueEndOfPipeActionPatchGcrCntl_nid_no_patch(void);
int APS5_VABI sceAgcWaitRegMemPatchReference_nid_no_patch(void);
int APS5_VABI sceAgcAcbRewind_nid_no_patch(void);
int APS5_VABI sceAgcAcbCondExecGetSize_nid_no_patch(void);
int APS5_VABI sceAgcSuspendPointAndCheckStatus_nid_no_patch(void);
int APS5_VABI sceAgcAcbWaitRegMem_nid_no_patch(void);
int APS5_VABI sceAgcDcbAcquireMem_nid_no_patch(void);
int APS5_VABI sceAgcSetCxRegIndirectPatchSetNumRegisters_nid_no_patch(void);
int APS5_VABI sceAgcDcbContextStateOp_nid_no_patch(void);
int APS5_VABI sceAgcAcbWriteData_nid_no_patch(void);
int APS5_VABI sceAgcAcbDmaDataGetSize_nid_no_patch(void);
int APS5_VABI sceAgcCbSetShRegisterRangeDirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcCbNop_nid_no_patch(void);
int APS5_VABI sceAgcDcbResetQueue_nid_no_patch(void);
int APS5_VABI sceAgcDcbDmaData_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDmaDataPatchSetDstAddressOrOffset_nid_no_patch(void);
int APS5_VABI sceAgcCbQueueEndOfPipeActionGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetFlip_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetMarker_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetPredication_nid_no_patch(void);
int APS5_VABI sceAgcDcbAtomicMem_nid_no_patch(void);
int APS5_VABI sceAgcGetRegisterDefaults2Internal_nid_no_patch(void);
int APS5_VABI sceAgcSetShRegIndirectPatchAddRegisters_nid_no_patch(void);
int APS5_VABI sceAgcDcbPrimeUtcl2_nid_no_patch(void);
int APS5_VABI sceAgcAcbRewindGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetZPassPredicationEnableGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbWaitUntilSafeForRendering_nid_no_patch(void);
int APS5_VABI sceAgcBranchPatchSetThenTarget_nid_no_patch(void);
int APS5_VABI sceAgcSetCxRegIndirectPatchSetAddress_nid_no_patch(void);
int APS5_VABI sceAgcDcbAtomicMemGetSize_nid_no_patch(void);
int APS5_VABI sceAgcUpdatePrimState_nid_no_patch(void);
int APS5_VABI sceAgcCbNopGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbGetLodStats_nid_no_patch(void);
int APS5_VABI sceAgcWaitRegMemPatchAddress_nid_no_patch(void);
int APS5_VABI sceAgcQueueEndOfPipeActionPatchData_nid_no_patch(void);
int APS5_VABI sceAgcGetRegisterDefaultsInternal_nid_no_patch(void);
int APS5_VABI sceAgcInit_nid_no_patch(void);
int APS5_VABI sceAgcDcbDispatchIndirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbCondExec_nid_no_patch(void);
int APS5_VABI sceAgcAcbSetMarker_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexOffsetGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbJump_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetIndexCount_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetShRegistersIndirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbStallCommandBufferParserGetSize_nid_no_patch(void);
int APS5_VABI sceAgcSuspendPoint_nid_no_patch(void);
int APS5_VABI sceAgcWaitRegMemPatchMask_nid_no_patch(void);
int APS5_VABI sceAgcAcbDispatchIndirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbAtomicGdsGetSize_nid_no_patch(void);
int APS5_VABI sceAgcCbCondWrite_nid_no_patch(void);
int APS5_VABI sceAgcDcbEndOcclusionQueryGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetPredicationDisableGetSize_nid_no_patch(void);
int APS5_VABI sceAgcLinkShaders_nid_no_patch(void);
int APS5_VABI sceAgcDcbWaitRegMem_nid_no_patch(void);
int APS5_VABI sceAgcGetRegisterDefaults_nid_no_patch(void);
int APS5_VABI sceAgcCbSetShRegisterRangeDirect_nid_no_patch(void);
int APS5_VABI sceAgcSetCxRegIndirectPatchAddRegisters_nid_no_patch(void);
int APS5_VABI sceAgcDcbDispatchIndirect_nid_no_patch(void);
int APS5_VABI sceAgcCbMemSemaphore_nid_no_patch(void);
int APS5_VABI sceAgcCbSetUcRegisterRangeDirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcCbDispatch_nid_no_patch(void);
int APS5_VABI sceAgcDcbCopyDataGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexMultiInstancedGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDmaDataPatchSetSrcAddressOrOffsetOrImmediate_nid_no_patch(void);
int APS5_VABI sceAgcSetShRegIndirectPatchSetAddress_nid_no_patch(void);
int APS5_VABI sceAgcDcbJump_nid_no_patch(void);
int APS5_VABI sceAgcDcbJumpGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbPrimeUtcl2_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetCxRegisterDirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcQueueEndOfPipeActionPatchType_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetCxRegisterDirect_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndex_nid_no_patch(void);
int APS5_VABI sceAgcCbDispatchGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbGetLodStatsGetSize_nid_no_patch(void);
int APS5_VABI sceAgcGetDataPacketPayloadAddress_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndirect_nid_no_patch(void);
int APS5_VABI sceAgcAcbSetFlip_nid_no_patch(void);
int APS5_VABI sceAgcGetFusedShaderSize_nid_no_patch(void);
int APS5_VABI sceAgcSetRangePredication_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetShRegisterDirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbSetIndexSize_nid_no_patch(void);
int APS5_VABI sceAgcSetPacketPredication_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexOffset_nid_no_patch(void);
int APS5_VABI sceAgcAsyncRewindPatchSetRewindState_nid_no_patch(void);
int APS5_VABI sceAgcJumpPatchSetTarget_nid_no_patch(void);
int APS5_VABI sceAgcBranchPatchSetCompareAddress_nid_no_patch(void);
int APS5_VABI sceAgcAcbJumpGetSize_nid_no_patch(void);
int APS5_VABI sceAgcCbBranch_nid_no_patch(void);
int APS5_VABI sceAgcDcbDrawIndexIndirectGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbCopyData_nid_no_patch(void);
int APS5_VABI sceAgcDcbWriteDataGetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbAtomicMem_nid_no_patch(void);
int APS5_VABI sceAgcAcbPrimeUtcl2GetSize_nid_no_patch(void);
int APS5_VABI sceAgcAcbResetQueue_nid_no_patch(void);
int APS5_VABI sceAgcAcbQueueEndOfShaderActionGetSize_nid_no_patch(void);
int APS5_VABI sceAgcDcbBeginOcclusionQueryGetSize_nid_no_patch(void);
}
core/libs/prx/libSceAgcVsh/libSceAgcVsh.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAgcVsh/include/Api.hpp"
core/libs/prx/libSceAgcVshDebug/libSceAgcVshDebug.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAjm.native/Export.cpp
+1 -26
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAjm.native/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
@@ -13,32 +14,6 @@ static void AjmStub(const char* name) {
NotImplemented_nid_no_patch(name);
}
struct WVorbisHeaderPacketParameter {
std::size_t size;
std::int32_t channels;
std::uint32_t sampleRate;
std::int32_t bytesPerSecond;
std::int32_t shortBlockExponent;
std::int32_t longBlockExponent;
std::uint32_t reserved;
const void* setupPacket;
std::size_t setupPacketSize;
void* output;
std::size_t outputCapacity;
std::size_t outputSize;
};
struct WVorbisSetupPacketParameter {
std::size_t size;
std::int32_t channels;
std::uint32_t reserved;
const void* input;
std::size_t inputSize;
void* output;
std::size_t outputCapacity;
std::size_t outputSize;
};
static_assert(sizeof(WVorbisHeaderPacketParameter) == 72);
static_assert(offsetof(WVorbisHeaderPacketParameter, setupPacket) == 32);
static_assert(sizeof(WVorbisSetupPacketParameter) == 56);
core/libs/prx/libSceAjm.native/include/Api.hpp
+74
View File
@@ -0,0 +1,74 @@
#pragma once
#include "SceTypes.hpp"
struct WVorbisHeaderPacketParameter {
std::size_t size;
std::int32_t channels;
std::uint32_t sampleRate;
std::int32_t bytesPerSecond;
std::int32_t shortBlockExponent;
std::int32_t longBlockExponent;
std::uint32_t reserved;
const void* setupPacket;
std::size_t setupPacketSize;
void* output;
std::size_t outputCapacity;
std::size_t outputSize;
};
struct WVorbisSetupPacketParameter {
std::size_t size;
std::int32_t channels;
std::uint32_t reserved;
const void* input;
std::size_t inputSize;
void* output;
std::size_t outputCapacity;
std::size_t outputSize;
};
extern "C" {
int APS5_VABI sceAjmBatchJobEncode(AjmBatchInfo* info, uint32_t instance, const void* pcmInput, size_t pcmInputSize, void* bitstreamOutput, size_t bitstreamOutputSize, void* result);
const char* APS5_VABI sceAjmStrError(int error);
int APS5_VABI sceAjmDecWVorbisCreateHeaderPacket(WVorbisHeaderPacketParameter* param);
int APS5_VABI sceAjmDecWVorbisCreateSetupPacket(WVorbisSetupPacketParameter* parameter);
int APS5_VABI sceAjmBatchGetLog();
int APS5_VABI sceAjmInstanceAvailable();
uint32_t APS5_VABI sceAjmInstanceCodecType(uint32_t instanceId);
int APS5_VABI sceAjmInstanceExtend(uint32_t context, uint32_t codec, uint64_t flags, uint32_t instance);
int APS5_VABI sceAjmInstanceSwitch(uint32_t context, uint32_t codec, uint64_t flags, uint32_t instance);
int APS5_VABI sceAjmInitialize(int64_t reserved, uint32_t* context);
int APS5_VABI sceAjmFinalize(uint32_t context);
int APS5_VABI sceAjmModuleRegister(uint32_t context, uint32_t codec, int64_t reserved);
int APS5_VABI sceAjmModuleUnregister(uint32_t context, uint32_t codec);
int APS5_VABI sceAjmMemoryRegister(uint32_t context, void* ptr, size_t pages);
int APS5_VABI sceAjmMemoryUnregister(uint32_t context, void* ptr);
int APS5_VABI sceAjmInstanceCreate(uint32_t context, uint32_t codec, uint64_t flags, uint32_t* instance);
int APS5_VABI sceAjmInstanceDestroy(uint32_t context, uint32_t instance);
int APS5_VABI sceAjmDecAt9ParseConfigData(const void* configData, AjmDecAt9ConfigDataInfo* configInfo);
int APS5_VABI sceAjmDecMp3ParseFrame(const uint8_t* stream, uint32_t streamSize, int parseOfl, AjmDecMp3ParseFrame* frame);
int APS5_VABI sceAjmBatchInitialize(void* buffer, size_t size, AjmBatchInfo* info);
int APS5_VABI sceAjmBatchJobInitialize(AjmBatchInfo* info, uint32_t instance, const void* codecParameters, size_t codecParametersSize, void* result);
int APS5_VABI sceAjmBatchJobClearContext(AjmBatchInfo* info, uint32_t instance, void* result);
int APS5_VABI sceAjmBatchJobSetGaplessDecode(AjmBatchInfo* info, uint32_t instance, const void* gaplessDecode, int reset, void* result);
int APS5_VABI sceAjmBatchJobControl(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const void* sidebandInput, size_t sidebandInputSize, void* sidebandOutput, size_t sidebandOutputSize);
int APS5_VABI sceAjmBatchJobRunSplit(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const AjmBuffer* inputBuffers, size_t inputBuffersNum, const AjmBuffer* outputBuffers, size_t outputBuffersNum, void* sidebandOutput, size_t sidebandOutputSize);
int APS5_VABI sceAjmBatchJobRun(AjmBatchInfo* info, uint32_t instance, uint64_t flags, const void* dataInput, size_t dataInputSize, void* dataOutput, size_t dataOutputSize, void* sidebandOutput, size_t sidebandOutputSize);
int APS5_VABI sceAjmBatchJobSetResampleParameters(AjmBatchInfo* info, uint32_t instance, float ratio, uint32_t flags, void* result);
int APS5_VABI sceAjmBatchJobSetResampleParametersEx(AjmBatchInfo* info, uint32_t instance, float ratioStart, float ratioChangePerSample, uint32_t flags, void* result);
int APS5_VABI sceAjmBatchJobGetResampleInfo(AjmBatchInfo* info, uint32_t instance, void* result);
int APS5_VABI sceAjmBatchJobDecode(AjmBatchInfo* info, uint32_t instance, const void* bitstreamInput, size_t bitstreamInputSize, void* pcmOutput, size_t pcmOutputSize, void* result);
int APS5_VABI sceAjmBatchJobDecodeSplit(AjmBatchInfo* info, uint32_t instance, const AjmBuffer* inputBuffers, size_t inputBuffersNum, const AjmBuffer* outputBuffers, size_t outputBuffersNum, void* result);
int APS5_VABI sceAjmBatchJobDecodeSingle(AjmBatchInfo* info, uint32_t instance, const void* bitstreamInput, size_t bitstreamInputSize, void* pcmOutput, size_t pcmOutputSize, void* result);
int APS5_VABI sceAjmBatchJobGetGaplessDecode(AjmBatchInfo* info, uint32_t instance, void* result);
int APS5_VABI sceAjmBatchJobGetInfo(AjmBatchInfo* info, uint32_t instance, void* result);
int APS5_VABI sceAjmBatchJobGetCodecInfo(AjmBatchInfo* info, uint32_t instance, void* result, size_t resultSize);
int APS5_VABI sceAjmBatchJobGetStatistics(AjmBatchInfo* info, float interval, void* result);
int APS5_VABI sceAjmBatchStart(uint32_t context, const AjmBatchInfo* info, int priority, AjmBatchError* error, uint32_t* batch);
int APS5_VABI sceAjmBatchWait(uint32_t context, uint32_t batch, uint32_t timeout, AjmBatchError* error);
int APS5_VABI sceAjmBatchCancel(uint32_t context, uint32_t batch);
int APS5_VABI sceAjmBatchErrorDump(const AjmBatchInfo* info, AjmBatchError* error);
}
core/libs/prx/libSceAjm.native/libSceAjm.native.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAjm.native/include/Api.hpp"
core/libs/prx/libSceAjm.native/src/Ajm.cpp
+1 -1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAjm.native/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
@@ -1136,7 +1137,6 @@ std::size_t OpusPacketSamples(const std::uint8_t* packet, std::size_t size) {
return frames * frameSamples;
}
std::size_t OpusLength(const std::uint8_t* data, std::size_t size, std::size_t& at) {
if (at >= size) return SIZE_MAX;
const std::size_t first = data[at++];
core/libs/prx/libSceAjm/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAjm/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAjm/include/Api.hpp
+11
View File
@@ -0,0 +1,11 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAjmBatchJobControlBufferRa();
int APS5_VABI sceAjmBatchJobRunSplitBufferRa();
int APS5_VABI sceAjmBatchStartBuffer();
}
core/libs/prx/libSceAjm/libSceAjm.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAjm/include/Api.hpp"
core/libs/prx/libSceAjmi/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAjmi/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAjmi/include/Api.hpp
+10
View File
@@ -0,0 +1,10 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAjmBatchJobInlineBuffer(void);
int APS5_VABI sceAjmBatchJobRunBufferRa(void);
}
core/libs/prx/libSceAjmi/libSceAjmi.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAjmi/include/Api.hpp"
core/libs/prx/libSceAmpr/Export.cpp
+3 -17
View File
@@ -1,3 +1,5 @@
#include "prx/libc/include/Api.hpp"
#include "prx/libSceAmpr/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include <ctime>
@@ -226,22 +228,11 @@ static int RecordWriteAddressFromCounterPair(Apr::CommandBufferObject* buffer, v
static std::atomic_flag sharedPtrSpinLock;
struct AmmUsageStatsData {
std::uint64_t sizeInBytes;
std::uint16_t numPageTablePoolEntries;
std::uint16_t allocatedPageTablePoolEntries;
std::uint16_t highWatermarkAllocatedEntries;
std::uint16_t reserved;
std::uint32_t ringIdleFlags;
};
static_assert(sizeof(AmmUsageStatsData) == 0x18);
static constexpr std::uint16_t AmmPageTablePoolEntries = 512;
static constexpr std::uint32_t AmmRingIdleFlags = 0x7;
extern "C" {
int APS5_VABI _Cnd_init_nid_postfix(void** handle);
int APS5_VABI wcstombs_s_nid_postfix(std::size_t* result, char* destination, std::size_t capacity, const std::uint16_t* source, std::size_t limit);
[[noreturn]] void APS5_VABI __cxa_call_terminate_nid_postfix(void* exception);
int APS5_VABI sceAmprCommandBufferWriteAddressOnCompletion(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint64_t value) {
if (!ValidWriteAddress(address)) return SCE_KERNEL_ERROR_EINVAL;
@@ -624,11 +615,6 @@ std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteKernelEventQueue_04_00(std
return sizeof(Apr::WriteKernelEventQueueCommand);
}
struct AmmSubmitResult {
std::int32_t result;
std::uint32_t errorOffset;
};
int APS5_VABI sceAmprAmmCommandBufferConstructor(Apr::CommandBufferObject* buffer) {
(void)buffer;
return 0;
@@ -867,8 +853,8 @@ void APS5_VABI _Lock_shared_ptr_spin_lock_nid_postfix(void) {
while (sharedPtrSpinLock.test_and_set(std::memory_order_acquire)) std::this_thread::yield();
}
[[noreturn]] void APS5_VABI __cxa_call_unexpected_nid_postfix(void* unwindException) {
__cxa_call_terminate_nid_postfix(unwindException);
}
core/libs/prx/libSceAmpr/include/Api.hpp
+159
View File
@@ -0,0 +1,159 @@
#pragma once
#include "prx/libkernel/Apr/include/AprCommandBuffer.hpp"
#include "prx/libc/include/GuestTime.hpp"
#include "SceTypes.hpp"
struct AmmSubmitResult {
std::int32_t result;
std::uint32_t errorOffset;
};
struct AmmUsageStatsData {
std::uint64_t sizeInBytes;
std::uint16_t numPageTablePoolEntries;
std::uint16_t allocatedPageTablePoolEntries;
std::uint16_t highWatermarkAllocatedEntries;
std::uint16_t reserved;
std::uint32_t ringIdleFlags;
};
extern "C" {
int APS5_VABI sceAmprCommandBufferWriteAddressOnCompletion(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint64_t value);
int APS5_VABI sceAmprCommandBufferWriteCounterOnCompletion(Apr::CommandBufferObject* buffer, std::uint8_t counter, std::uint32_t value);
int APS5_VABI sceAmprCommandBufferWaitOnAddress(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint64_t reference, std::uint8_t compare, std::uint8_t flush);
int APS5_VABI sceAmprCommandBufferWaitOnCounter(Apr::CommandBufferObject* buffer, std::uint8_t counter, std::uint32_t reference, std::uint8_t compare, std::uint8_t flush);
int APS5_VABI sceAmprCommandBufferWriteKernelEventQueueOnCompletion(Apr::CommandBufferObject* buffer, std::uint64_t equeue, std::int32_t ident, std::uint64_t data);
int APS5_VABI sceAmprCommandBufferWriteAddressFromTimeCounterOnCompletion(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address);
int APS5_VABI sceAmprCommandBufferWriteAddressFromCounterOnCompletion(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint8_t counter);
int APS5_VABI sceAmprCommandBufferWriteAddressFromCounterPairOnCompletion(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint8_t counter);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteAddressOnCompletion();
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteCounterOnCompletion();
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWaitOnAddress();
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWaitOnCounter();
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteKernelEventQueueOnCompletion();
int APS5_VABI sceAmprAprCommandBufferConstructor(Apr::CommandBufferObject* buffer, uint64_t* gatherState, uint64_t* scatterState);
int APS5_VABI sceAmprAprCommandBufferDestructor(Apr::CommandBufferObject* buffer, uint64_t* gatherState, uint64_t* scatterState);
int APS5_VABI sceAmprAprCommandBufferMapBegin(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection);
int APS5_VABI sceAmprAprCommandBufferMapDirectBegin(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t directOffset, std::uint64_t size, std::int32_t type, std::int32_t protection);
int APS5_VABI sceAmprAprCommandBufferMapEnd(Apr::CommandBufferObject* buffer);
int APS5_VABI sceAmprAprCommandBufferReadFile(Apr::CommandBufferObject* buffer, uint64_t* gatherState, uint64_t* scatterState, uint32_t fileId, void* destination, uint64_t size, uint64_t offset);
int APS5_VABI sceAmprAprCommandBufferReadFileGather(Apr::CommandBufferObject* buffer, std::uint64_t* mapState, std::uint64_t* scatterGatherState, std::uint64_t size, std::uint64_t offset);
int APS5_VABI sceAmprAprCommandBufferReadFileGatherScatter(Apr::CommandBufferObject* buffer, std::uint64_t* mapState, std::uint64_t* scatterGatherState, void* destination, std::uint64_t size, std::uint64_t offset);
int APS5_VABI sceAmprAprCommandBufferReadFileScatter(Apr::CommandBufferObject* buffer, std::uint64_t* mapState, std::uint64_t* scatterGatherState, void* destination, std::uint64_t size);
int APS5_VABI sceAmprAprCommandBufferResetGatherScatterState(Apr::CommandBufferObject* buffer);
void* APS5_VABI sceAmprCommandBufferClearBuffer(Apr::CommandBufferObject* buffer);
int APS5_VABI sceAmprCommandBufferConstructMarker(Apr::CommandBufferObject* buffer, std::uint32_t type, const char* text, const std::uint32_t* color);
int APS5_VABI sceAmprCommandBufferConstructNop(Apr::CommandBufferObject* buffer, std::int16_t type, const void* payload, std::uint32_t payloadBytes, const std::uint32_t* word);
int APS5_VABI sceAmprCommandBufferConstructor(Apr::CommandBufferObject* buffer);
int APS5_VABI sceAmprCommandBufferDestructor(Apr::CommandBufferObject* buffer);
void* APS5_VABI sceAmprCommandBufferGetBufferBaseAddress(const Apr::CommandBufferObject* buffer);
uint32_t APS5_VABI sceAmprCommandBufferGetCurrentOffset(const Apr::CommandBufferObject* buffer);
uint32_t APS5_VABI sceAmprCommandBufferGetNumCommands(const Apr::CommandBufferObject* buffer);
uint32_t APS5_VABI sceAmprCommandBufferGetSize(const Apr::CommandBufferObject* buffer);
uint32_t APS5_VABI sceAmprCommandBufferGetType(const Apr::CommandBufferObject* buffer);
int APS5_VABI sceAmprCommandBufferNop(Apr::CommandBufferObject* buffer, std::uint32_t dwords);
int APS5_VABI sceAmprCommandBufferNopWithData(Apr::CommandBufferObject* buffer, std::uint32_t dwords, const std::uint32_t* data);
int APS5_VABI sceAmprCommandBufferPopMarker(Apr::CommandBufferObject* buffer);
int APS5_VABI sceAmprCommandBufferPushMarker(Apr::CommandBufferObject* buffer, const char* text);
int APS5_VABI sceAmprCommandBufferPushMarkerWithColor(Apr::CommandBufferObject* buffer, const char* text, std::uint32_t color);
int APS5_VABI sceAmprCommandBufferReset(Apr::CommandBufferObject* buffer);
int APS5_VABI sceAmprCommandBufferSetBuffer(Apr::CommandBufferObject* buffer, void* memory, uint32_t size);
int APS5_VABI sceAmprCommandBufferSetMarker(Apr::CommandBufferObject* buffer, const char* text);
int APS5_VABI sceAmprCommandBufferSetMarkerWithColor(Apr::CommandBufferObject* buffer, const char* text, const std::uint32_t* color);
int APS5_VABI sceAmprCommandBufferWaitOnAddress_04_00(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint64_t reference, std::uint8_t compare, std::uint8_t flush);
int APS5_VABI sceAmprCommandBufferWaitOnCounter_04_00(Apr::CommandBufferObject* buffer, std::uint8_t counter, std::uint8_t access, std::uint64_t reference, std::uint8_t compare, std::uint8_t maskOperation, std::uint64_t mask, std::uint8_t flush);
int APS5_VABI sceAmprCommandBufferWriteAddressFromCounterPair_04_00(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint8_t counter, std::uint64_t atStart);
int APS5_VABI sceAmprCommandBufferWriteAddressFromCounter_04_00(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint8_t counter, std::uint64_t atStart);
int APS5_VABI sceAmprCommandBufferWriteAddressFromTimeCounter_04_00(Apr::CommandBufferObject* buffer, volatile std::uint64_t* address, std::uint64_t atStart);
int APS5_VABI sceAmprCommandBufferWriteAddress_04_00(Apr::CommandBufferObject* buffer, uint64_t* address, uint64_t value, uint32_t flags);
int APS5_VABI sceAmprCommandBufferWriteCounter_04_00(Apr::CommandBufferObject* buffer, std::uint8_t counter, std::uint8_t access, std::uint64_t value, std::uint8_t operation, std::uint8_t atStart);
int APS5_VABI sceAmprCommandBufferWriteKernelEventQueue_04_00(Apr::CommandBufferObject* buffer, std::uint64_t equeue, std::int32_t ident, std::uint64_t data, std::uint64_t atStart);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeMapBegin(std::uint64_t address, std::uint64_t size, std::uint32_t type, std::uint32_t protection);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeMapDirectBegin(std::uint64_t address, std::uint64_t directOffset, std::uint64_t size, std::uint32_t type, std::uint32_t protection);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeMapEnd();
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeNop(std::uint32_t dwords);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeNopWithData(std::uint32_t dwords);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizePopMarker();
std::uint64_t APS5_VABI sceAmprMeasureCommandSizePushMarker(const char* text);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizePushMarkerWithColor(const char* text, std::uint32_t color);
uint32_t APS5_VABI sceAmprMeasureCommandSizeReadFile(void);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeReadFileGather(std::uint64_t size, std::uint64_t offset);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeReadFileGatherScatter(void* destination, std::uint64_t size, std::uint64_t offset);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeReadFileScatter(void* destination, std::uint64_t size);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeResetGatherScatterState();
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeSetMarker(const char* text);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeSetMarkerWithColor(const char* text, std::uint32_t color);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWaitOnAddress_04_00(volatile std::uint64_t* address, std::uint64_t, std::uint8_t compare, std::uint8_t flush);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWaitOnCounter_04_00(std::uint8_t, std::uint8_t access, std::uint64_t, std::uint8_t compare, std::uint8_t maskOperation, std::uint64_t, std::uint8_t flush);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteAddressFromCounterPair_04_00(volatile std::uint64_t* address, std::uint8_t counter);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteAddressFromCounter_04_00(volatile std::uint64_t* address, std::uint8_t counter);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteAddressFromTimeCounter_04_00(volatile std::uint64_t* address);
uint32_t APS5_VABI sceAmprMeasureCommandSizeWriteAddress_04_00(void);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteCounter_04_00(std::uint8_t counter, std::uint8_t access, std::uint64_t, std::uint8_t operation);
std::uint64_t APS5_VABI sceAmprMeasureCommandSizeWriteKernelEventQueue_04_00(std::uint64_t, std::int32_t, std::uint64_t);
int APS5_VABI sceAmprAmmCommandBufferConstructor(Apr::CommandBufferObject* buffer);
int APS5_VABI sceAmprAmmCommandBufferDestructor(Apr::CommandBufferObject* buffer);
int APS5_VABI sceAmprAmmCommandBufferMap(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection);
int APS5_VABI sceAmprAmmCommandBufferMapWithGpuMaskId(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection, std::uint8_t gpuMaskId);
int APS5_VABI sceAmprAmmCommandBufferMapDirect(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t directOffset, std::uint64_t size, std::int32_t type, std::int32_t protection);
int APS5_VABI sceAmprAmmCommandBufferMapDirectWithGpuMaskId(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t directOffset, std::uint64_t size, std::int32_t type, std::int32_t protection, std::uint8_t gpuMaskId);
int APS5_VABI sceAmprAmmCommandBufferUnmap(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeMap(std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeMapWithGpuMaskId(std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection, std::uint8_t gpuMaskId);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeMapDirect(std::uint64_t address, std::uint64_t directOffset, std::uint64_t size, std::int32_t type, std::int32_t protection);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeMapDirectWithGpuMaskId(std::uint64_t address, std::uint64_t directOffset, std::uint64_t size, std::int32_t type, std::int32_t protection, std::uint8_t gpuMaskId);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeUnmap(std::uint64_t address, std::uint64_t size);
int APS5_VABI sceAmprAmmCommandBufferRemap(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t source, std::uint64_t size, std::int32_t protection);
int APS5_VABI sceAmprAmmCommandBufferRemapWithGpuMaskId(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t source, std::uint64_t size, std::int32_t protection, std::uint8_t gpuMaskId);
int APS5_VABI sceAmprAmmCommandBufferMultiMap(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t alias, std::uint64_t size, std::int32_t protection);
int APS5_VABI sceAmprAmmCommandBufferMultiMapWithGpuMaskId(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t alias, std::uint64_t size, std::int32_t protection, std::uint8_t gpuMaskId);
int APS5_VABI sceAmprAmmCommandBufferModifyProtect(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size, std::int32_t protection, std::int32_t mask);
int APS5_VABI sceAmprAmmCommandBufferModifyProtectWithGpuMaskId(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size, std::int32_t protection, std::int32_t mask, std::uint8_t gpuMaskId);
int APS5_VABI sceAmprAmmCommandBufferModifyMtypeProtect(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection, std::int32_t mask);
int APS5_VABI sceAmprAmmCommandBufferModifyMtypeProtectWithGpuMaskId(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection, std::int32_t mask, std::uint8_t gpuMaskId);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeRemap(std::uint64_t address, std::uint64_t source, std::uint64_t size, std::int32_t protection);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeRemapWithGpuMaskId(std::uint64_t address, std::uint64_t source, std::uint64_t size, std::int32_t protection, std::uint8_t gpuMaskId);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeMultiMap(std::uint64_t address, std::uint64_t alias, std::uint64_t size, std::int32_t protection);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeMultiMapWithGpuMaskId(std::uint64_t address, std::uint64_t alias, std::uint64_t size, std::int32_t protection, std::uint8_t gpuMaskId);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeModifyProtect(std::uint64_t address, std::uint64_t size, std::int32_t protection, std::int32_t mask);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeModifyProtectWithGpuMaskId(std::uint64_t address, std::uint64_t size, std::int32_t protection, std::int32_t mask, std::uint8_t gpuMaskId);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeModifyMtypeProtect(std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection, std::int32_t mask);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeModifyMtypeProtectWithGpuMaskId(std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection, std::int32_t mask, std::uint8_t gpuMaskId);
int APS5_VABI sceAmprAmmCommandBufferMapAsPrt(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size);
int APS5_VABI sceAmprAmmCommandBufferAllocatePaForPrt(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection);
int APS5_VABI sceAmprAmmCommandBufferRemapIntoPrt(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t source, std::uint64_t size, std::int32_t protection, std::uint32_t opcode);
int APS5_VABI sceAmprAmmCommandBufferUnmapToPrt(Apr::CommandBufferObject* buffer, std::uint64_t address, std::uint64_t size);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeMapAsPrt(std::uint64_t address, std::uint64_t size);
std::int64_t APS5_VABI sceAmprAmmMeasureAmmCommandSizeAllocatePaForPrt(std::uint64_t address, std::uint64_t size, std::int32_t type, std::int32_t protection);
int APS5_VABI sceAmprAmmGiveDirectMemory(std::int64_t searchStart, std::int64_t searchEnd, std::size_t size, std::size_t alignment, int usage, std::int64_t* offset);
int APS5_VABI sceAmprAmmGetVirtualAddressRanges(std::uint64_t* start, std::uint64_t* end, std::uint64_t* multimapStart, std::uint64_t* multimapEnd);
int APS5_VABI sceAmprAmmSetPageTablePoolOccupancyNotificationThreshold(void);
int APS5_VABI sceAmprAmmSubmitCommandBuffer(void* base, std::uint32_t offset, std::uint32_t priority);
int APS5_VABI sceAmprAmmSubmitCommandBuffer2(void* base, std::uint32_t offset, std::uint32_t priority, AmmSubmitResult* result, std::uint32_t* id);
int APS5_VABI sceAmprAmmSubmitCommandBuffer3(void* base, std::uint32_t offset, std::uint32_t priority, std::uint32_t* id);
int APS5_VABI sceAmprAmmWaitCommandBufferCompletion(std::uint32_t id);
void APS5_VABI _Unlock_shared_ptr_spin_lock_nid_postfix(void);
int APS5_VABI _Cnd_init_with_name_nid_postfix(void** handle, const char*);
int APS5_VABI _ZNKSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE3getES3_S3_RSt8ios_baseRNSt5_IosbIiE8_IostateEP2tmPKcSE__nid_postfix(void);
int APS5_VABI _ZNSt8time_getIcSt19istreambuf_iteratorIcSt11char_traitsIcEEE7_GetcatEPPKNSt6locale5facetEPKS5__nid_postfix(void);
void APS5_VABI _Lock_shared_ptr_spin_lock_nid_postfix(void);
SonyLconv* APS5_VABI sceAmprLocaleconv(void);
unsigned __int128 APS5_VABI sceAmprUdivti3(unsigned __int128 dividend, unsigned __int128 divisor);
double APS5_VABI sceAmprSinh(double x, double y);
char* APS5_VABI sceAmprStrtokS(char* str, const char* delim, char** context);
int APS5_VABI sceAmprCtimeS(char* buffer, std::size_t size, const std::int64_t* time);
int APS5_VABI sceAmprWcscpyS(std::uint16_t* dest, std::size_t size, const std::uint16_t* src);
void* APS5_VABI sceAmprSetConstraintHandlerS(void* handler);
int APS5_VABI sceAmprFltrounds(void);
void APS5_VABI sceAmprIgnoreHandlerS(const char* message, void* pointer, int error);
int APS5_VABI sceAmprWcstombsS(std::size_t* result, char* destination, std::size_t capacity, const std::uint16_t* source, std::size_t limit);
std::size_t APS5_VABI sceAmprMbstowcs(std::uint16_t* dest, const char* src, std::size_t size);
int APS5_VABI sceAmprAsctimeS(char* buffer, std::size_t size, const GuestTm* time);
int APS5_VABI sceAmprFpclassifyd(double value);
int APS5_VABI sceAmprAmmGetUsageStatsData(AmmUsageStatsData* stats);
[[noreturn]] void APS5_VABI __cxa_call_unexpected_nid_postfix(void* unwindException);
}
core/libs/prx/libSceAmpr/libSceAmpr.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAmpr/include/Api.hpp"
core/libs/prx/libSceAppChecker/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAppChecker/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAppChecker/include/Api.hpp
+11
View File
@@ -0,0 +1,11 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAppCheckerAbort();
int APS5_VABI sceAppCheckerExecute();
int APS5_VABI sceAppCheckerExecuteEx();
}
core/libs/prx/libSceAppChecker/libSceAppChecker.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAppChecker/include/Api.hpp"
core/libs/prx/libSceAppContent/Export.cpp
+1 -6
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAppContent/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
@@ -26,11 +27,6 @@ static constexpr char TEMPORARY_MOUNT_POINT[] = "/temp0";
static constexpr char DOWNLOAD_MOUNT_POINT[] = "/download0";
static constexpr uint32_t TEMPORARY_DATA_OPTION_FORMAT = 1;
struct AppContentAddcontInfo {
NpUnifiedEntitlementLabel entitlement_label;
uint32_t status;
};
namespace {
std::atomic_bool initialized{false};
@@ -209,7 +205,6 @@ int APS5_VABI sceAppContentTemporaryDataUnmount(const AppContentMountPoint* moun
return 0;
}
int APS5_VABI sceAppContentAddcontEnqueueDownload(uint32_t service_label, const NpUnifiedEntitlementLabel* entitlement_label) {
if (!initialized.load()) return SCE_APP_CONTENT_ERROR_NOT_INITIALIZED;
(void)service_label;
core/libs/prx/libSceAppContent/include/Api.hpp
+45
View File
@@ -0,0 +1,45 @@
#pragma once
#include "SceTypes.hpp"
struct AppContentAddcontInfo {
NpUnifiedEntitlementLabel entitlement_label;
uint32_t status;
};
extern "C" {
int APS5_VABI sceAppContentAddcontMount(uint32_t serviceLabel, const NpUnifiedEntitlementLabel* entitlementLabel, AppContentMountPoint* mountPoint);
int APS5_VABI sceAppContentAddcontUnmount(const AppContentMountPoint* mountPoint);
int APS5_VABI sceAppContentGetAddcontInfo(uint32_t serviceLabel, const NpUnifiedEntitlementLabel* entitlementLabel, AppContentAddcontInfo* info);
int APS5_VABI sceAppContentGetAddcontInfoList(uint32_t serviceLabel, AppContentAddcontInfo* list, uint32_t listNum, uint32_t* hitNum);
int APS5_VABI sceAppContentAppParamGetInt(uint32_t paramId, int32_t* value);
int APS5_VABI sceAppContentDownloadDataFormat(const AppContentMountPoint* mountPoint);
int APS5_VABI sceAppContentDownloadDataGetAvailableSpaceKb(const AppContentMountPoint* mountPoint, size_t* availableSpaceKb);
int APS5_VABI sceAppContentInitialize(const AppContentInitParam* initParam, AppContentBootParam* bootParam);
int APS5_VABI sceAppContentTemporaryDataFormat(const AppContentMountPoint* mountPoint);
int APS5_VABI sceAppContentTemporaryDataGetAvailableSpaceKb(const AppContentMountPoint* mountPoint, size_t* availableSpaceKb);
int APS5_VABI sceAppContentTemporaryDataMount2(uint32_t option, AppContentMountPoint* mountPoint);
int APS5_VABI sceAppContentTemporaryDataUnmount(const AppContentMountPoint* mountPoint);
int APS5_VABI sceAppContentAddcontEnqueueDownload(uint32_t serviceLabel, const NpUnifiedEntitlementLabel* entitlementLabel);
int APS5_VABI sceAppContentAddcontDelete(uint32_t serviceLabel, const NpUnifiedEntitlementLabel* entitlementLabel);
int APS5_VABI sceAppContentGetAddcontDownloadProgress(uint32_t serviceLabel, const NpUnifiedEntitlementLabel* entitlementLabel, void* progress);
int APS5_VABI sceAppContentAddcontEnqueueDownloadByEntitlemetId(void);
int APS5_VABI sceAppContentAddcontEnqueueDownloadSp(void);
int APS5_VABI sceAppContentAddcontMountByEntitlemetId(void);
int APS5_VABI sceAppContentAddcontShrink(void);
int APS5_VABI sceAppContentAppParamGetString(void);
int APS5_VABI sceAppContentDownload0Expand(void);
int APS5_VABI sceAppContentDownload0Shrink(void);
int APS5_VABI sceAppContentDownload1Expand(void);
int APS5_VABI sceAppContentDownload1Shrink(void);
int APS5_VABI sceAppContentGetAddcontInfoByEntitlementId(void);
int APS5_VABI sceAppContentGetAddcontInfoListByIroTag(void);
int APS5_VABI sceAppContentGetDownloadedStoreCountry(void);
int APS5_VABI sceAppContentGetEntitlementKey(void);
int APS5_VABI sceAppContentGetPftFlag(void);
int APS5_VABI sceAppContentGetRegion(void);
int APS5_VABI sceAppContentRequestPatchInstall(void);
int APS5_VABI sceAppContentTemporaryDataMount(AppContentMountPoint* mountPoint);
}
core/libs/prx/libSceAppContent/libSceAppContent.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAppContent/include/Api.hpp"
core/libs/prx/libSceAppDbShellCoreClient/libSceAppDbShellCoreClient.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAppDbShellCoreClientForSystemService/libSceAppDbShellCoreClientForSystemService.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAppInstUtil/Export.cpp
+1 -2
View File
@@ -1,10 +1,9 @@
#include "prx/libSceAppInstUtil/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
#include "prx/libc/include/General.hpp"
struct AppInstallProgressInfo;
extern "C" {
int APS5_VABI sceAppInstUtilInitialize(void) {
core/libs/prx/libSceAppInstUtil/include/Api.hpp
+29
View File
@@ -0,0 +1,29 @@
#pragma once
#include "SceTypes.hpp"
struct AppInstallProgressInfo;
extern "C" {
int APS5_VABI sceAppInstUtilInitialize(void);
int APS5_VABI sceAppInstUtilTerminate(void);
int APS5_VABI sceAppInstUtilAppInstallAll(void* reserved);
int APS5_VABI sceAppInstUtilAppInstallTitleDir(const char* titleId, const char* titleDir, void* reserved);
int APS5_VABI sceAppInstUtilAppIsInInstalling(int32_t* installing);
int APS5_VABI sceAppInstUtilAppIsInUpdating(const char* titleId, bool* updating);
int APS5_VABI sceAppInstUtilAppExists(const char* titleId, int32_t* exists);
int APS5_VABI sceAppInstUtilAppGetSize(const char* titleId, std::uint64_t* size);
int APS5_VABI sceAppInstUtilAppInstallPkg(const char* packagePath, std::uint64_t serviceArgument);
int APS5_VABI sceAppInstUtilAppPrepareOverwritePkg();
int APS5_VABI sceAppInstUtilAppRecoverApp();
int APS5_VABI sceAppInstUtilAppUnInstall(const char* titleId);
int APS5_VABI sceAppInstUtilAppUnInstallAddcont(const char* titleId, const char* contentLabel);
int APS5_VABI sceAppInstUtilAppUnInstallPat(const char* titleId);
int APS5_VABI sceAppInstUtilAppUnInstallTheme();
int APS5_VABI sceAppInstUtilAppUnInstallTypes(const char* titleId, std::uint32_t types);
int APS5_VABI sceAppInstUtilGetInstallProgressInfo(const char* titleId, AppInstallProgressInfo* info);
int APS5_VABI sceAppInstUtilGetInstallProgress(const char* titleId, void* progress);
int APS5_VABI sceAppInstUtilGetPrimaryAppSlot(const char* titleId, void* slot);
}
core/libs/prx/libSceAppInstUtil/libSceAppInstUtil.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAppInstUtil/include/Api.hpp"
core/libs/prx/libSceAsyncStorageInternal/libSceAsyncStorageInternal.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAt9Enc/Export.cpp
+1 -1
View File
@@ -1,9 +1,9 @@
#include "prx/libSceAt9Enc/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
#include "prx/libc/include/General.hpp"
extern "C" {
int32_t APS5_VABI sceAt9EncClearContext(void *pAt9EncWorkArea, int32_t *pInternalResult) {
core/libs/prx/libSceAt9Enc/include/Api.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int32_t APS5_VABI sceAt9EncClearContext(void *pAt9EncWorkArea, int32_t *pInternalResult);
int32_t APS5_VABI sceAt9EncCreateEncoder(void *pAt9EncWorkArea, void *pAt9EncParam, int32_t memSize, int32_t *pInternalResult);
int32_t APS5_VABI sceAt9EncEncode(void *pAt9EncWorkArea, const void *pInputBuf, void *pOutputBuf, uint32_t inputBufSize, uint32_t outputBufSize, uint32_t *pOutputDataByte, uint32_t *pUsedBufSize, int32_t *pInternalResult);
int32_t APS5_VABI sceAt9EncFlush(void *pAt9EncWorkArea, void *pOutputBuf, uint32_t outputBufSize, uint32_t *pOutputDataByte, int32_t *pInternalResult);
int32_t APS5_VABI sceAt9EncQueryMemSize(void *pAt9EncParam, int32_t *pMemSize, int32_t *pInternalResult);
}
core/libs/prx/libSceAt9Enc/libSceAt9Enc.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAt9Enc/include/Api.hpp"
core/libs/prx/libSceAudio/libSceAudio.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudioLatencyEstimation/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAudioLatencyEstimation/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAudioLatencyEstimation/include/Api.hpp
+12
View File
@@ -0,0 +1,12 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAudioLatencyEstimationAddData();
int APS5_VABI sceAudioLatencyEstimationGetDelayTime();
int APS5_VABI sceAudioLatencyEstimationInitialize();
int APS5_VABI sceAudioLatencyEstimationRelease();
}
core/libs/prx/libSceAudioLatencyEstimation/libSceAudioLatencyEstimation.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAudioLatencyEstimation/include/Api.hpp"
core/libs/prx/libSceAudioOut/tests/AudioOutLastOutputTime.cpp
+2 -5
View File
@@ -1,3 +1,4 @@
#include "prx/libkernel/Time/include/Time.hpp"
#include "prx/libSceAudioOut/include/AudioOut.hpp"
#include "SceTypes.hpp"
#include "prx/libc/include/general/VabiMacros.hpp"
@@ -10,11 +11,6 @@
#include <thread>
#include <vector>
extern "C" {
std::uint64_t APS5_VABI sceKernelGetProcessTime();
}
static void Require(bool value, const char* message) {
if (value) return;
std::fprintf(stderr, "%s\n", message);
@@ -227,6 +223,7 @@ int main() {
setenv("SDL_AUDIODRIVER", "dummy", 1);
#endif
sceKernelGetProcessTime();
TestOutput(portTypeMain);
TestOutput(portTypeVibration);
TestPortsAreIndependent();
core/libs/prx/libSceAudioPropagation/Export.cpp
+2
View File
@@ -1,3 +1,5 @@
#include "prx/libSceAudioPropagation/include/Api.hpp"
#include "prx/libSceAudioPropagation/AudioPropagation.hpp"
#include "AudioPropagation.hpp"
#include "prx/libc/include/General.hpp"
core/libs/prx/libSceAudioPropagation/include/Api.hpp
+18
View File
@@ -0,0 +1,18 @@
#pragma once
#include "prx/libSceAudioPropagation/AudioPropagation.hpp"
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAudioPropagationReportApi(std::uint32_t category, AudioPropagationHandle handle, std::int32_t result, std::int32_t operation, const char* function, const char* format, ...);
int APS5_VABI sceAudioPropagationResetAttributes(AudioPropagation::Attribute* attributes, std::uint32_t count);
int APS5_VABI sceAudioPropagationSourceQueryInfo(AudioPropagationHandle source, AudioPropagation::SourceInfo* info);
int APS5_VABI sceAudioPropagationSystemLock(AudioPropagationHandle system);
int APS5_VABI sceAudioPropagationSystemQueryInfo(AudioPropagationHandle system, AudioPropagation::SystemInfo* info, std::size_t size);
int APS5_VABI sceAudioPropagationReportRegisterHandler(std::uint32_t category, AudioPropagation::ReportHandler handler, void* userData, AudioPropagation::ReportRegistration** registration);
int APS5_VABI sceAudioPropagationReportUnregisterHandler(AudioPropagation::ReportRegistration* registration);
int APS5_VABI sceAudioPropagationSystemEnumHandles(AudioPropagationHandle* handles, std::uint32_t capacity);
int APS5_VABI sceAudioPropagationSystemUnlock(AudioPropagationHandle system);
}
core/libs/prx/libSceAudioPropagation/libSceAudioPropagation.hpp
+4
View File
@@ -0,0 +1,4 @@
#pragma once
#include "prx/libSceAudioPropagation/AudioPropagation.hpp"
#include "prx/libSceAudioPropagation/include/Api.hpp"
core/libs/prx/libSceAudioSystem/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAudioSystem/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAudioSystem/include/Api.hpp
+10
View File
@@ -0,0 +1,10 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAudioSystemSystemResume();
int APS5_VABI sceAudioSystemSystemSuspend();
}
core/libs/prx/libSceAudioSystem/libSceAudioSystem.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAudioSystem/include/Api.hpp"
core/libs/prx/libSceAudiodReport/libSceAudiodReport.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodec.native/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAudiodec.native/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAudiodec.native/include/Api.hpp
+22
View File
@@ -0,0 +1,22 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAudiodecClearContextEx(void);
int APS5_VABI sceAudiodecCreateDecoderEx(void);
int APS5_VABI sceAudiodecDecode2(void);
int APS5_VABI sceAudiodecDecode2Ex(void);
int APS5_VABI sceAudiodecDecode2WithPriority(void);
int APS5_VABI sceAudiodecDecode2WithPriorityEx(void);
int APS5_VABI sceAudiodecDecodeEx(void);
int APS5_VABI sceAudiodecDecodeWithPriority(void);
int APS5_VABI sceAudiodecDecodeWithPriorityEx(void);
int APS5_VABI sceAudiodecDeleteDecoderEx(void);
int APS5_VABI sceAudiodecGetContext(void);
int APS5_VABI sceAudiodecInitialize(void);
int APS5_VABI sceAudiodecRegisterCodec(void);
int APS5_VABI sceAudiodecTerminate(void);
}
core/libs/prx/libSceAudiodec.native/libSceAudiodec.native.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAudiodec.native/include/Api.hpp"
core/libs/prx/libSceAudiodec/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAudiodec/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include <array>
core/libs/prx/libSceAudiodec/include/Api.hpp
+14
View File
@@ -0,0 +1,14 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int32_t APS5_VABI sceAudiodecInitLibrary(uint32_t codecType);
int32_t APS5_VABI sceAudiodecTermLibrary(uint32_t codecType);
int32_t APS5_VABI sceAudiodecCreateDecoder(AudiodecCtrl* ctrl, uint32_t codecType);
int32_t APS5_VABI sceAudiodecDeleteDecoder(int32_t handle);
int32_t APS5_VABI sceAudiodecClearContext(int32_t handle);
int32_t APS5_VABI sceAudiodecDecode(int32_t handle, AudiodecCtrl* ctrl);
}
core/libs/prx/libSceAudiodec/libSceAudiodec.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAudiodec/include/Api.hpp"
core/libs/prx/libSceAudiodecCpu/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAudiodecCpu/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAudiodecCpu/include/Api.hpp
+16
View File
@@ -0,0 +1,16 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAudiodecCpuClearContext(void);
int APS5_VABI sceAudiodecCpuDecode(void);
int APS5_VABI sceAudiodecCpuInitDecoder(void);
int APS5_VABI sceAudiodecCpuInternalClearContext(void);
int APS5_VABI sceAudiodecCpuInternalDecode(void);
int APS5_VABI sceAudiodecCpuInternalInitDecoder(void);
int APS5_VABI sceAudiodecCpuInternalQueryMemSize(void);
int APS5_VABI sceAudiodecCpuQueryMemSize(void);
}
core/libs/prx/libSceAudiodecCpu/libSceAudiodecCpu.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAudiodecCpu/include/Api.hpp"
core/libs/prx/libSceAudiodecCpuAlac/libSceAudiodecCpuAlac.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodecCpuDdp/libSceAudiodecCpuDdp.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodecCpuDts/libSceAudiodecCpuDts.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodecCpuDtsHdLbr/libSceAudiodecCpuDtsHdLbr.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodecCpuDtsHdMa/libSceAudiodecCpuDtsHdMa.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodecCpuFlac/libSceAudiodecCpuFlac.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodecCpuLpcm/libSceAudiodecCpuLpcm.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodecCpuM4aac/libSceAudiodecCpuM4aac.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAudiodecCpuTrhd/libSceAudiodecCpuTrhd.hpp
+1
View File
@@ -0,0 +1 @@
#pragma once
core/libs/prx/libSceAutoMounterClient/Export.cpp
+1 -12
View File
@@ -1,20 +1,9 @@
#include "prx/libSceAutoMounterClient/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
#include "prx/libc/include/General.hpp"
struct AutoMounterUsbDeviceInfo {
char deviceName[128];
std::byte metadata[22];
std::byte data0[256];
std::byte padding[2];
std::uint64_t data0Size;
std::byte data1[256];
std::uint64_t data1Size;
std::byte data2[256];
std::uint64_t data2Size;
};
static_assert(sizeof(AutoMounterUsbDeviceInfo) == 944);
static_assert(offsetof(AutoMounterUsbDeviceInfo, data0) == 150);
static_assert(offsetof(AutoMounterUsbDeviceInfo, data0Size) == 408);
core/libs/prx/libSceAutoMounterClient/include/Api.hpp
+26
View File
@@ -0,0 +1,26 @@
#pragma once
#include "SceTypes.hpp"
struct AutoMounterUsbDeviceInfo {
char deviceName[128];
std::byte metadata[22];
std::byte data0[256];
std::byte padding[2];
std::uint64_t data0Size;
std::byte data1[256];
std::uint64_t data1Size;
std::byte data2[256];
std::uint64_t data2Size;
};
extern "C" {
int APS5_VABI sceAutoMounterClientGetUsbDeviceInfo(const char* deviceName, AutoMounterUsbDeviceInfo* info);
int APS5_VABI sceAutoMounterClientGetUsbDeviceList(char (*deviceNames)[64], std::int32_t* count);
int APS5_VABI sceAutoMounterClientInit(PthreadAttr* threadAttr);
int APS5_VABI sceAutoMounterClientRegisterCallback();
int APS5_VABI sceAutoMounterClientTerm();
int APS5_VABI sceAutoMounterClientUnregisterCallback();
}
core/libs/prx/libSceAutoMounterClient/libSceAutoMounterClient.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAutoMounterClient/include/Api.hpp"
core/libs/prx/libSceAvPlayer.native/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAvPlayer.native/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAvPlayer.native/include/Api.hpp
+10
View File
@@ -0,0 +1,10 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAvPlayerPrintf(void);
int APS5_VABI sceAvPlayerVprintf(void);
}
core/libs/prx/libSceAvPlayer.native/libSceAvPlayer.native.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAvPlayer.native/include/Api.hpp"
core/libs/prx/libSceAvPlayer/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAvPlayer/include/Api.hpp"
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
core/libs/prx/libSceAvPlayer/include/Api.hpp
+47
View File
@@ -0,0 +1,47 @@
#pragma once
#include "prx/libSceAvPlayer/include/AvPlayer.hpp"
#include "SceTypes.hpp"
#include <algorithm>
#include <atomic>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <limits>
#include <optional>
#include <string_view>
#include <vector>
extern "C" {
int APS5_VABI sceAvPlayerAddSource(AvPlayerInternal* h, const char* filename);
int APS5_VABI sceAvPlayerAddSourceEx(AvPlayerInternal* h, uint32_t uriType, const AvPlayerSourceDetails* sourceDetails);
int APS5_VABI sceAvPlayerChangeStream(AvPlayerInternal* h, uint32_t oldStreamId, uint32_t newStreamId);
int APS5_VABI sceAvPlayerClose(AvPlayerInternal* h);
uint64_t APS5_VABI sceAvPlayerCurrentTime(AvPlayerInternal* h);
int APS5_VABI sceAvPlayerDisableStream(AvPlayerInternal* h, uint32_t streamId);
int APS5_VABI sceAvPlayerEnableStream(AvPlayerInternal* h, uint32_t streamId);
Bool APS5_VABI sceAvPlayerGetAudioData(AvPlayerInternal* h, AvPlayerFrameInfo* audioInfo);
int APS5_VABI sceAvPlayerGetStreamInfo(AvPlayerInternal* h, uint32_t streamId, AvPlayerStreamInfo* info);
int APS5_VABI sceAvPlayerGetStreamInfoEx(AvPlayerInternal* h, uint32_t streamId, AvPlayerStreamInfoEx* info);
Bool APS5_VABI sceAvPlayerGetVideoData(AvPlayerInternal* h, AvPlayerFrameInfo* videoInfo);
Bool APS5_VABI sceAvPlayerGetVideoDataEx(AvPlayerInternal* h, AvPlayerFrameInfoEx* videoInfo);
AvPlayerInternal* APS5_VABI sceAvPlayerInit(AvPlayerInitData* init);
int APS5_VABI sceAvPlayerInitEx(const AvPlayerInitDataEx* initEx, AvPlayerInternal** handle);
Bool APS5_VABI sceAvPlayerIsActive(AvPlayerInternal* h);
int APS5_VABI sceAvPlayerJumpToTime(AvPlayerInternal* h, uint64_t timeMs);
int APS5_VABI sceAvPlayerPause(AvPlayerInternal* h);
int APS5_VABI sceAvPlayerPostInit(AvPlayerInternal* h, const AvPlayerPostInitData* postInit);
int APS5_VABI sceAvPlayerResume(AvPlayerInternal* h);
int APS5_VABI sceAvPlayerSetAvSyncMode(AvPlayerInternal* h, uint32_t syncMode);
int APS5_VABI sceAvPlayerSetAvailableBandwidth(AvPlayerInternal* h, uint32_t startBandwidth, uint32_t minimumBandwidth, uint32_t maximumBandwidth);
int APS5_VABI sceAvPlayerSetLogCallback(void* callback, void* userData);
int APS5_VABI sceAvPlayerSetLooping(AvPlayerInternal* h, Bool loop);
int APS5_VABI sceAvPlayerSetTrickSpeed(AvPlayerInternal* h, int32_t trickSpeed);
int APS5_VABI sceAvPlayerStart(AvPlayerInternal* h);
int APS5_VABI sceAvPlayerStartEx(AvPlayerInternal* handle, const AvPlayer::StartInfo* startInfo);
int APS5_VABI sceAvPlayerStop(AvPlayerInternal* h);
int APS5_VABI sceAvPlayerStreamCount(AvPlayerInternal* h);
}
core/libs/prx/libSceAvPlayer/libSceAvPlayer.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAvPlayer/include/Api.hpp"
core/libs/prx/libSceAvPlayerStreaming/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAvPlayerStreaming/include/Api.hpp"
#include <cstddef>
#include <cstdint>
#include "SceTypes.hpp"
core/libs/prx/libSceAvPlayerStreaming/include/Api.hpp
+41
View File
@@ -0,0 +1,41 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI MvpHttpAbort_nid_postfix(void);
int APS5_VABI MvpHttpDeInit_nid_postfix(void);
int APS5_VABI MvpHttpGet_nid_postfix(void);
int APS5_VABI MvpHttpGetLastError_nid_postfix(void);
int APS5_VABI MvpHttpHead_nid_postfix(void);
int APS5_VABI MvpHttpHeadCleanup_nid_postfix(void);
int APS5_VABI MvpHttpInit_nid_postfix(void);
int APS5_VABI MvpHttpPost_nid_postfix(void);
int APS5_VABI MvpHttpSetCert_nid_postfix(void);
int APS5_VABI MvpHttpSetRecvTimeout_nid_postfix(void);
int APS5_VABI MvpHttpSetRedirectCb_nid_postfix(void);
int APS5_VABI sceTsCloseFile(void);
int APS5_VABI sceTsDisableRepresentation(void);
int APS5_VABI sceTsEnableRepresentation(void);
int APS5_VABI sceTsEnableStream(void);
int APS5_VABI sceTsGetAvailableBW(void);
int APS5_VABI sceTsGetLiveStatus(void);
int APS5_VABI sceTsGetNextAuInfo(void);
int APS5_VABI sceTsGetNextUnitData(void);
int APS5_VABI sceTsGetRepresentationCount(void);
int APS5_VABI sceTsGetRepresentationInfo(void);
int APS5_VABI sceTsGetSeekWindow(void);
int APS5_VABI sceTsGetStreamInfo(void);
int APS5_VABI sceTsGetUrlEncryptionType(void);
int APS5_VABI sceTsJumpPTS(void);
int APS5_VABI sceTsOpenFile(void);
int APS5_VABI sceTsOpenFileEx(void);
int APS5_VABI sceTsReleaseBuffer(void);
int APS5_VABI sceTsRepresentationIsEnabled(void);
int APS5_VABI sceTsSetAvailableBW(void);
int APS5_VABI sceTsSetStartingBW(void);
int APS5_VABI sceTsStartFileStreaming(void);
int APS5_VABI sceTsStopFileStreaming(void);
}
core/libs/prx/libSceAvPlayerStreaming/libSceAvPlayerStreaming.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAvPlayerStreaming/include/Api.hpp"
core/libs/prx/libSceAvSetting/Export.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "prx/libSceAvSetting/include/Api.hpp"
#include <cstdint>
#include <cstddef>
#include "SceTypes.hpp"
core/libs/prx/libSceAvSetting/include/Api.hpp
+32
View File
@@ -0,0 +1,32 @@
#pragma once
#include "SceTypes.hpp"
extern "C" {
int APS5_VABI sceAvControlGetPuTypeByMonitorInfo(void);
int APS5_VABI sceAvControlIsVideoOutModeSupportedByMonitorInfoWithOptions(void);
int APS5_VABI sceAvControlSetDitherModeForDiag(void);
int APS5_VABI sceAvControlSetLayoutModeForDiag(void);
int APS5_VABI sceAvControlSetMonitorFakeMode(void);
int APS5_VABI sceAvControlGetCurrentOutputSysMode(void);
int APS5_VABI sceAvControlGetNativeHdmiMonitorInfo(void);
int APS5_VABI sceAvControlGetRawMonitorInfo(void);
int APS5_VABI sceAvControlGetKsvList(void);
int APS5_VABI sceAvControlGetRawEdid(void);
int APS5_VABI sceAvControlRemoveProcessOutputMode(void);
int APS5_VABI sceAvControlUpdateDriverStatus(void);
int APS5_VABI sceAvControlNotifyUmdEvent(void);
int APS5_VABI sceAvControlAddCallbacksForLnc(void);
int APS5_VABI sceAvControlAddCallbacksForResourceArbitrator(void);
int APS5_VABI sceAvControlRemoveCallbacks(void);
int APS5_VABI sceAvControlCheckCallback(void);
int APS5_VABI sceAvControlWaitCallback(void);
int APS5_VABI sceAvControlSetColorMode(void);
int APS5_VABI sceAvControlCheckMonitorInfoCapability(void);
int APS5_VABI sceAvControlCheckVideoOutMode(void);
int APS5_VABI sceAvControlSetCheckoutputMode(void);
int APS5_VABI sceAvControlSetSystemVideoMode(void);
int APS5_VABI sceAvControlDebugAddCallbacks(void);
}
core/libs/prx/libSceAvSetting/libSceAvSetting.hpp
+3
View File
@@ -0,0 +1,3 @@
#pragma once
#include "prx/libSceAvSetting/include/Api.hpp"
Loaded 100 of 1491 files, more files were not shown because too many files have changed in this diff. Show more