From d0f2684dce95b3cf4f4cbf0829d4d6ab402ea0dd Mon Sep 17 00:00:00 2001 From: JJenkx Date: Fri, 16 Oct 2026 02:51:17 -0400 Subject: [PATCH] feat(ajm): decode ATRAC9 vibration channel configurations --- .gitmodules | 3 + 3rdparty/vgmstream | 1 + core/libs/prx/libSceAjm.native/CMakeLists.txt | 17 +- core/libs/prx/libSceAjm.native/src/Ajm.cpp | 46 ++++- core/libs/tests/GuestAjmVibration.cpp | 163 ++++++++++++++++++ docs/dev/debt/libSceAjm.native.md | 1 + tools/package_release.py | 9 +- tools/tests/test_package_release.py | 12 ++ 8 files changed, 248 insertions(+), 4 deletions(-) create mode 160000 3rdparty/vgmstream create mode 100644 core/libs/tests/GuestAjmVibration.cpp diff --git a/.gitmodules b/.gitmodules index f68f95f507..cca8971537 100644 --- a/.gitmodules +++ b/.gitmodules @@ -46,3 +46,6 @@ [submodule "3rdparty/ZArchive"] path = 3rdparty/ZArchive url = https://github.com/Exzap/ZArchive.git +[submodule "3rdparty/vgmstream"] + path = 3rdparty/vgmstream + url = https://github.com/vgmstream/vgmstream.git diff --git a/3rdparty/vgmstream b/3rdparty/vgmstream new file mode 160000 index 0000000000..7c520e8f9b --- /dev/null +++ b/3rdparty/vgmstream @@ -0,0 +1 @@ +Subproject commit 7c520e8f9b078dfde2f84f1b5bcbad0c6c415806 diff --git a/core/libs/prx/libSceAjm.native/CMakeLists.txt b/core/libs/prx/libSceAjm.native/CMakeLists.txt index 94f14ef4bc..51b7c2507f 100644 --- a/core/libs/prx/libSceAjm.native/CMakeLists.txt +++ b/core/libs/prx/libSceAjm.native/CMakeLists.txt @@ -22,6 +22,13 @@ add_library(atrac9 STATIC EXCLUDE_FROM_ALL target_include_directories(atrac9 PRIVATE ${LIBATRAC9_DIR}) set_target_properties(atrac9 PROPERTIES POSITION_INDEPENDENT_CODE ON) +set(VGMSTREAM_ATRAC9_DIR ${CMAKE_SOURCE_DIR}/3rdparty/vgmstream/src/coding/libs) +add_library(atrac9_vibration STATIC EXCLUDE_FROM_ALL + ${VGMSTREAM_ATRAC9_DIR}/atrac9_dec.c + ${VGMSTREAM_ATRAC9_DIR}/atrac9_internal.c +) +set_target_properties(atrac9_vibration PROPERTIES POSITION_INDEPENDENT_CODE ON C_VISIBILITY_PRESET hidden) + add_library(libSceAjm.native SHARED EXCLUDE_FROM_ALL ${CMAKE_CURRENT_SOURCE_DIR}/Export.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/Ajm.cpp @@ -30,8 +37,9 @@ add_library(libSceAjm.native SHARED EXCLUDE_FROM_ALL target_include_directories(libSceAjm.native PRIVATE ${LIBS_INCLUDE_DIR} ${LIBATRAC9_DIR} + ${VGMSTREAM_ATRAC9_DIR} ) -target_link_libraries(libSceAjm.native PRIVATE atrac9 ffmpeg libc libkernel) +target_link_libraries(libSceAjm.native PRIVATE atrac9 atrac9_vibration ffmpeg libc libkernel) configure_windows_unwind(libSceAjm.native) if(BUILD_TESTING) @@ -58,6 +66,11 @@ if(BUILD_TESTING) target_link_libraries(guest_ajm_tests PRIVATE libSceAjm.native libc) configure_windows_unwind(guest_ajm_tests) add_test(NAME guest_ajm COMMAND guest_ajm_tests) + add_test_executable(guest_ajm_vibration_tests ${LIBS_INCLUDE_DIR}/tests/GuestAjmVibration.cpp) + target_include_directories(guest_ajm_vibration_tests PRIVATE ${LIBS_INCLUDE_DIR}) + target_link_libraries(guest_ajm_vibration_tests PRIVATE libSceAjm.native libc) + configure_windows_unwind(guest_ajm_vibration_tests) + add_test(NAME guest_ajm_vibration COMMAND guest_ajm_vibration_tests) if(UNIX) add_test_executable(guest_ajm_teardown_tests ${LIBS_INCLUDE_DIR}/tests/GuestAjmTeardown.cpp) target_include_directories(guest_ajm_teardown_tests PRIVATE ${LIBS_INCLUDE_DIR}) @@ -66,7 +79,7 @@ if(BUILD_TESTING) add_test(NAME guest_ajm_teardown COMMAND guest_ajm_teardown_tests $) endif() if(WIN32) - set_tests_properties(guest_ajm PROPERTIES ENVIRONMENT_MODIFICATION + set_tests_properties(guest_ajm guest_ajm_vibration PROPERTIES ENVIRONMENT_MODIFICATION "PATH=path_list_prepend:$") endif() endif() diff --git a/core/libs/prx/libSceAjm.native/src/Ajm.cpp b/core/libs/prx/libSceAjm.native/src/Ajm.cpp index 29fe39434e..62207cfc2a 100644 --- a/core/libs/prx/libSceAjm.native/src/Ajm.cpp +++ b/core/libs/prx/libSceAjm.native/src/Ajm.cpp @@ -4,12 +4,14 @@ #include "prx/libc/include/General.hpp" #include "libatrac9.h" extern "C" { +#include "atrac9_dec.h" #include #include #include #include } #include +#include #include #include #include @@ -134,6 +136,7 @@ struct Instance { std::uint32_t codec = 0; std::uint64_t flags = 0; void* decoder = nullptr; + atrac9_handle_t* vibrationDecoder = nullptr; std::vector channelDecoders; std::vector channelBytes; std::vector blockPcm; @@ -170,6 +173,7 @@ struct Instance { ~Instance() { if (decoder) Atrac9ReleaseHandle(decoder); + atrac9_free(vibrationDecoder); for (void* channelDecoder : channelDecoders) Atrac9ReleaseHandle(channelDecoder); if (mp3) avcodec_free_context(&mp3); if (opus) avcodec_free_context(&opus); @@ -298,7 +302,23 @@ bool ParseMultichannelConfig(const std::uint8_t* config, At9MultichannelConfig& return true; } +bool IsAt9Vibration(const std::uint8_t* config) { + return config[0] == 0xFE && ((config[1] >> 1u) & 7u) >= 6u; +} + bool DescribeAt9Config(const std::uint8_t* configData, Atrac9CodecInfo& info) { + if (IsAt9Vibration(configData)) { + atrac9_info_t vibration{}; + if (atrac9_get_config_info(configData, &vibration) != 0 || vibration.sample_rate <= 0) return false; + info.channels = vibration.channels; + info.channelConfigIndex = (configData[1] >> 1u) & 7u; + info.samplingRate = vibration.sample_rate; + info.superframeSize = vibration.superframe_size; + info.framesInSuperframe = vibration.frames_per_superframe; + info.frameSamples = vibration.frame_samples; + std::memcpy(info.configData, configData, ATRAC9_CONFIG_DATA_SIZE); + return true; + } At9MultichannelConfig multichannel{}; const bool isMultichannel = ParseMultichannelConfig(configData, multichannel); unsigned char config[ATRAC9_CONFIG_DATA_SIZE]; @@ -321,12 +341,18 @@ bool DescribeAt9Config(const std::uint8_t* configData, Atrac9CodecInfo& info) { bool ResetDecoder(Instance& instance) { if (instance.decoder) Atrac9ReleaseHandle(instance.decoder); instance.decoder = nullptr; + atrac9_free(instance.vibrationDecoder); + instance.vibrationDecoder = nullptr; for (void* channelDecoder : instance.channelDecoders) Atrac9ReleaseHandle(channelDecoder); instance.channelDecoders.clear(); instance.superframeRemaining = 0; instance.frameInSuperframe = 0; unsigned char config[ATRAC9_CONFIG_DATA_SIZE]; std::memcpy(config, instance.info.configData, sizeof(config)); + if (IsAt9Vibration(config)) { + instance.vibrationDecoder = atrac9_init(config); + return instance.vibrationDecoder != nullptr; + } At9MultichannelConfig multichannel{}; if (!ParseMultichannelConfig(config, multichannel)) { instance.decoder = Atrac9GetHandle(); @@ -341,7 +367,7 @@ bool ResetDecoder(Instance& instance) { } bool HasAt9Decoder(const Instance& instance) { - return instance.decoder || !instance.channelDecoders.empty(); + return instance.decoder || instance.vibrationDecoder || !instance.channelDecoders.empty(); } int DecodeAt9Block(void* decoder, std::uint32_t encoding, const std::uint8_t* data, int size, std::uint8_t* pcm, int* used) { @@ -355,6 +381,24 @@ int DecodeAt9Block(void* decoder, std::uint32_t encoding, const std::uint8_t* da constexpr int AT9_MULTICHANNEL_BLOCK_OVERRUN = 0x7F000001; int DecodeAt9Frame(Instance& instance, const std::uint8_t* data, int size, std::uint8_t* pcm, std::uint32_t encoding, std::size_t sampleBytes, int* used) { + if (instance.vibrationDecoder) { + int samples = 0; + if (encoding == 0) samples = atrac9_decode_pcm16(instance.vibrationDecoder, data, size, reinterpret_cast(pcm), used); + else if (encoding == 2) samples = atrac9_decode_float(instance.vibrationDecoder, data, size, reinterpret_cast(pcm), used); + else { + std::array decoded{}; + samples = atrac9_decode(instance.vibrationDecoder, data, size, decoded.data(), used); + if (samples > 0) { + const auto count = static_cast(samples) * instance.info.channels; + if (count > decoded.size()) return AT9_MULTICHANNEL_BLOCK_OVERRUN; + for (std::size_t index = 0; index < count; ++index) { + const auto value = static_cast(std::clamp(static_cast(decoded[index]) * 65536.0, -2147483648.0, 2147483647.0)); + std::memcpy(pcm + index * sizeof(value), &value, sizeof(value)); + } + } + } + return samples < 0 ? samples : samples == instance.info.frameSamples ? 0 : AT9_MULTICHANNEL_BLOCK_OVERRUN; + } if (instance.channelDecoders.empty()) return DecodeAt9Block(instance.decoder, encoding, data, size, pcm, used); const std::size_t channels = instance.channelDecoders.size(); const auto frameSamples = static_cast(instance.info.frameSamples); diff --git a/core/libs/tests/GuestAjmVibration.cpp b/core/libs/tests/GuestAjmVibration.cpp new file mode 100644 index 0000000000..c905c6282e --- /dev/null +++ b/core/libs/tests/GuestAjmVibration.cpp @@ -0,0 +1,163 @@ +#include "SceTypes.hpp" +#include "prx/libc/include/general/VabiMacros.hpp" +#include +#include +#include +#include +#include +#include +#include + +extern "C" { +int APS5_VABI sceAjmInitialize(std::int64_t, std::uint32_t*); +int APS5_VABI sceAjmFinalize(std::uint32_t); +int APS5_VABI sceAjmDecAt9ParseConfigData(const void*, AjmDecAt9ConfigDataInfo*); +int APS5_VABI sceAjmInstanceCreate(std::uint32_t, std::uint32_t, std::uint64_t, std::uint32_t*); +int APS5_VABI sceAjmInstanceDestroy(std::uint32_t, std::uint32_t); +int APS5_VABI sceAjmBatchInitialize(void*, std::size_t, AjmBatchInfo*); +int APS5_VABI sceAjmBatchJobInitialize(AjmBatchInfo*, std::uint32_t, const void*, std::size_t, void*); +int APS5_VABI sceAjmBatchJobRun(AjmBatchInfo*, std::uint32_t, std::uint64_t, const void*, std::size_t, void*, std::size_t, void*, std::size_t); +int APS5_VABI sceAjmBatchStart(std::uint32_t, const AjmBatchInfo*, int, AjmBatchError*, std::uint32_t*); +int APS5_VABI sceAjmBatchWait(std::uint32_t, std::uint32_t, std::uint32_t, AjmBatchError*); +} + +namespace { +void Require(bool value, const char* message) { + if (!value) throw std::runtime_error(message); +} + +void Submit(std::uint32_t context, const AjmBatchInfo& info) { + AjmBatchError error{}; + std::uint32_t id = 0; + Require(sceAjmBatchStart(context, &info, 0, &error, &id) == 0 && sceAjmBatchWait(context, id, 0, &error) == 0, "batch submit"); +} + +std::array Config(unsigned channels) { + return {0xFE, static_cast(channels == 1 ? 0x7C : 0x7E), 0x03, 0xF0}; +} + +std::vector Packet(const std::vector& amplitudes) { + std::vector bytes; + std::size_t position = 0; + const auto put = [&](unsigned value, unsigned bits) { + for (unsigned bit = bits; bit > 0; --bit) { + if (position / 8 == bytes.size()) bytes.push_back(0); + bytes[position / 8] |= ((value >> (bit - 1)) & 1u) << (7 - position % 8); + ++position; + } + }; + for (unsigned frame = 0; frame < 4; ++frame) { + for (const auto amplitude : amplitudes) { + put(frame != 0, 1); + put(0, 1); + put(0, 1); + put(0, 4); + put(25, 5); + put(6, 3); + put(static_cast(amplitude) & 255u, 8); + put(static_cast(-amplitude) & 255u, 8); + while (position % 8 != 0) put(0, 1); + } + } + bytes.resize(128, 1); + return bytes; +} + +struct Stream { + std::int32_t result = -1; + std::int32_t internalResult = -1; + std::int32_t consumed = -1; + std::int32_t produced = -1; + std::uint64_t samples = 0; + std::uint32_t frames = 0; + std::uint32_t reserved = 0; +}; + +template +std::vector Decode(std::uint32_t context, unsigned channels, unsigned encoding, const std::vector& amplitudes, bool partial = false, bool malformed = false) { + std::uint32_t instance = 0; + Require(sceAjmInstanceCreate(context, 1, static_cast(encoding) << 7u, &instance) == 0, "create vibration instance"); + const auto config = Config(channels); + std::vector batch(4096); + AjmBatchInfo info{}; + std::int32_t initialized[2] = {-1, -1}; + Require(sceAjmBatchInitialize(batch.data(), batch.size(), &info) == 0, "initialize batch"); + Require(sceAjmBatchJobInitialize(&info, instance, config.data(), config.size(), initialized) == 0, "append initialize"); + Submit(context, info); + Require(initialized[0] == 0 && initialized[1] == 0, "initialize vibration decoder"); + auto packet = Packet(amplitudes); + std::vector pcm(1024 * channels); + constexpr std::uint64_t flags = (1ull << 47) | (1ull << 12); + const auto run = [&](const std::vector& input, std::size_t size) { + Stream stream; + Require(sceAjmBatchInitialize(batch.data(), batch.size(), &info) == 0, "reset batch"); + Require(sceAjmBatchJobRun(&info, instance, flags, input.data(), size, pcm.data(), pcm.size() * sizeof(T), &stream, sizeof(stream)) == 0, "append run"); + Submit(context, info); + return stream; + }; + if (partial) { + std::fill(pcm.begin(), pcm.end(), T{123}); + const auto stream = run(packet, packet.size() - 1); + Require(stream.result == 8 && stream.consumed == 0 && stream.produced == 0, "partial superframe accounting"); + Require(std::all_of(pcm.begin(), pcm.end(), [](T value) { return value == T{123}; }), "partial input changed PCM"); + } + if (malformed) { + auto broken = packet; + broken[0] |= 0x80; + const auto stream = run(broken, broken.size()); + Require((stream.result & 2) != 0 && stream.consumed == 0 && stream.produced == 0, "invalid first-frame flag"); + } + const auto stream = run(packet, packet.size()); + Require(stream.result == 0 && stream.internalResult == 0, "decode vibration superframe"); + Require(stream.consumed == 128 && stream.produced == static_cast(pcm.size() * sizeof(T)), "consumed/produced accounting"); + Require(stream.samples == 1024 && stream.frames == 4, "decoded sample/frame accounting"); + Require(sceAjmInstanceDestroy(context, instance) == 0, "destroy instance"); + return pcm; +} + +void Parse() { + for (const auto index : {6u, 7u}) { + for (const auto profile : {1u, 4u, 7u}) { + auto config = Config(index == 6 ? 1 : 2); + config[1] = static_cast((profile << 4) | (index << 1)); + AjmDecAt9ConfigDataInfo info{}; + Require(sceAjmDecAt9ParseConfigData(config.data(), &info) == 0, "parse vibration config"); + const unsigned samples = profile == 1 ? 64 : profile == 4 ? 128 : 256; + Require(info.channels == (index == 6 ? 1u : 2u) && info.sample_rate == (profile == 1 ? 12000u : profile == 4 ? 24000u : 48000u), "vibration layout/rate"); + Require(info.superframe_size == 128 && info.frame_samples_per_channel == samples && info.superframe_samples_per_channel == samples * 4, "vibration frame geometry"); + } + } + auto invalid = Config(2); + invalid[1] |= 1; + AjmDecAt9ConfigDataInfo info; + std::memset(&info, 0xAA, sizeof(info)); + Require(sceAjmDecAt9ParseConfigData(invalid.data(), &info) == static_cast(0x80930005), "invalid version accepted"); + Require(info.superframe_size == 0xAAAAAAAAu, "invalid parse changed output"); +} +} + +int main() { + try { + Parse(); + std::uint32_t context = 0; + Require(sceAjmInitialize(0, &context) == 0, "initialize AJM"); + const auto left = Decode(context, 1, 2, {1}); + const auto right = Decode(context, 1, 2, {2}); + const auto stereo = Decode(context, 2, 2, {1, 2}, true, true); + Require(std::any_of(left.begin(), left.end(), [](float value) { return std::abs(value) > 0.000001f; }), "vibration decoded to silence"); + for (std::size_t sample = 0; sample < left.size(); ++sample) { + Require(std::isfinite(stereo[2 * sample]) && std::isfinite(stereo[2 * sample + 1]), "non-finite PCM"); + Require(stereo[2 * sample] == left[sample] && stereo[2 * sample + 1] == right[sample], "dual-mono interleaving or reset history"); + } + const auto pcm16 = Decode(context, 2, 0, {1, 2}); + const auto pcm32 = Decode(context, 2, 1, {1, 2}); + for (std::size_t sample = 0; sample < stereo.size(); ++sample) { + Require(std::abs(static_cast(pcm16[sample]) / 32768.0 - stereo[sample]) <= 1.0 / 32768.0, "PCM16 conversion"); + Require(std::abs(static_cast(pcm32[sample]) / 2147483648.0 - stereo[sample]) <= 1.0 / 2147483648.0, "PCM32 conversion"); + } + Require(sceAjmFinalize(context) == 0, "finalize AJM"); + } catch (const std::exception& error) { + std::fprintf(stderr, "%s\n", error.what()); + return 1; + } +} diff --git a/docs/dev/debt/libSceAjm.native.md b/docs/dev/debt/libSceAjm.native.md index bcdfde9b1e..725dc88e4a 100644 --- a/docs/dev/debt/libSceAjm.native.md +++ b/docs/dev/debt/libSceAjm.native.md @@ -3,6 +3,7 @@ ### Unknown function info - [sceAjmInstanceCreate](../../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native) - a full 14-bit instance slot namespace returns `0x80930007` (`OUT_OF_RESOURCES`), as [shadPS4's InstanceCreate](https://github.com/shadps4-emu/shadPS4/blob/15abf68c9b52c4b04d094f2837719fdb871021f3/src/core/libraries/ajm/ajm_context.cpp) does for its own instance pool (PS4). The 16384 slots per codec prefix are this runtime's existing ID layout, not a measured console capacity; the PS5 capacity and exhaustion result are unverified. +- [ATRAC9 vibration decoding](../../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native): channel configurations 6 (mono) and 7 (dual mono) use the pinned [vgmstream decoder](https://github.com/vgmstream/vgmstream/blob/7c520e8f9b078dfde2f84f1b5bcbad0c6c415806/src/coding/libs/atrac9_dec.c), including its 12/24/48 kHz profile limits. Synthetic fixtures cover interleaving, reset after malformed input, partial superframes and PCM16/PCM32/float output; console PCM rounding and physical haptic output are unverified. Ordinary channel configurations and discrete multichannel streams still use LibAtrac9. Decoder creation and decoding run under the existing AJM instance lock because the dependency rebuilds shared Huffman tables during initialization. - [sceAjmDecWVorbisCreateHeaderPacket, sceAjmDecWVorbisCreateSetupPacket](../../../core/libs/prx/libSceAjm.native/Export.cpp) (libSceAjmWVorbis, implemented in libSceAjm.native) - unknown signatures - [sceAjmBatchJobGetInfo](../../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native) - writes the result and format sideband of a run job without buffers with the `SIDEBAND_FORMAT` flag (0x400000000000), as [KytyPS5](https://github.com/KytyPS5/KytyPS5) does, not confirmed on a PS5 title; the format reports bitrate 0 for ATRAC9 as in KytyPS5, while [shadPS4](https://github.com/shadps4-emu/shadPS4) derives it from the superframe size; before the instance is initialized it returns the not-initialized result (1) and no format, like the other run jobs here, while KytyPS5 returns result 0 with the format of the uninitialized decoder - [sceAjmDecMp3ParseFrame](../../../core/libs/prx/libSceAjm.native/src/Ajm.cpp) (libSceAjm.native) - signature, result layout and rate tables taken from the [shadPS4](https://github.com/shadps4-emu/shadPS4) reimplementation of the PS4 library, not confirmed on a PS5 title: the layer field is not checked and MPEG-2.5 stops at 64 kbps; the original file length (`parse_ofl`) layout (Xing/Info + LAME tag, VBRI, Fraunhofer `0xB4` block with its CRC, encoder delay = samples per frame + LAME delay + 529) also comes from shadPS4 only, and the Fraunhofer block has no other public description diff --git a/tools/package_release.py b/tools/package_release.py index 20daabb45e..11e8fc9d67 100644 --- a/tools/package_release.py +++ b/tools/package_release.py @@ -46,12 +46,15 @@ def package(platform, build, output, version): raise RuntimeError(f"Missing patched libraries: {', '.join(sorted(missing))}") executable = "relinker.exe" if platform == "windows" else "relinker" files = [library for library in libraries if library.name in expected] + licenses = [] + if "libSceAjm.native.prx" in expected: + licenses.append((ROOT / "3rdparty/vgmstream/COPYING", "libs/licenses/vgmstream.txt")) if platform == "windows": runtime = windows_runtime(build) files.extend(runtime / name for name in ("libgcc_s_seh-1.dll", "libstdc++-6.dll", "libwinpthread-1.dll")) files.extend(tracy_runtime(platform, build)) binary = build / "core/relinker" / executable - for file in [*files, binary]: + for file in [*files, binary, *(source for source, _ in licenses)]: if not file.is_file() or file.stat().st_size == 0: raise RuntimeError(f"Missing or empty release file: {file}") asset = f"relinker-{version}.exe" if platform == "windows" else f"relinker-{version}" @@ -72,9 +75,13 @@ def package(platform, build, output, version): with zipfile.ZipFile(staging / f"prx-{platform}-{version}.zip", "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as archive: for file in files: archive.write(file, arcname=f"libs/{file.name}") + for source, destination in licenses: + archive.write(source, arcname=destination) with tarfile.open(staging / f"prx-{platform}-{version}.tar.gz", "w:gz", compresslevel=9, dereference=True) as archive: for file in files: archive.add(file, arcname=f"libs/{file.name}") + for source, destination in licenses: + archive.add(source, arcname=destination) shutil.copy2(binary, staging / asset) for file in sorted(staging.iterdir()): file.replace(output / file.name) diff --git a/tools/tests/test_package_release.py b/tools/tests/test_package_release.py index 05ba91343f..eeaf2e2315 100644 --- a/tools/tests/test_package_release.py +++ b/tools/tests/test_package_release.py @@ -47,6 +47,18 @@ class ReleasePackageTests(unittest.TestCase): self.addCleanup(patch.stopall) patch.object(package_release, "ROOT", self.source, create=True).start() + def test_ajm_vibration_decoder_license_in_archives(self): + (self.source / "core/libs/prx/libSceAjm.native").mkdir() + (self.build / "core/libs/libs/libSceAjm.native.prx").write_bytes(b"ajm") + license_file = self.source / "3rdparty/vgmstream/COPYING" + license_file.parent.mkdir(parents=True) + license_file.write_bytes(b"decoder license") + package_release.package("linux", self.build, self.output, "v1") + with zipfile.ZipFile(self.output / "prx-linux-v1.zip") as archive: + self.assertEqual(archive.read("libs/licenses/vgmstream.txt"), b"decoder license") + with tarfile.open(self.output / "prx-linux-v1.tar.gz") as archive: + self.assertEqual(archive.extractfile("libs/licenses/vgmstream.txt").read(), b"decoder license") + def test_windows_runtime_follows_the_configured_compiler_directory(self): runtime = self.root / "custom toolchain" / "bin" runtime.mkdir(parents=True)