early-access version 3582

README.md

@@ -1,7 +1,7 @@
 yuzu emulator early access
 =============
 
-This is the source code for early-access 3581.
+This is the source code for early-access 3582.
 
 ## Legal Notice
 

src/core/file_sys/savedata_factory.cpp

@@ -82,9 +82,9 @@ std::string GetFutureSaveDataPath(SaveDataSpaceId space_id, SaveDataType type, u
     // Only detect account/device saves from the future location.
     switch (type) {
     case SaveDataType::SaveData:
-        return fmt::format("{}/account/{}/{:016X}/1", space_id_path, uuid.RawString(), title_id);
+        return fmt::format("{}/account/{}/{:016X}/0", space_id_path, uuid.RawString(), title_id);
     case SaveDataType::DeviceSaveData:
-        return fmt::format("{}/device/{:016X}/1", space_id_path, title_id);
+        return fmt::format("{}/device/{:016X}/0", space_id_path, title_id);
     default:
         return "";
     }

src/core/hle/service/am/am.cpp

@@ -13,6 +13,7 @@
 #include "core/file_sys/savedata_factory.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_transfer_memory.h"
+#include "core/hle/result.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
@@ -1335,7 +1336,7 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
         {24, nullptr, "GetLaunchStorageInfoForDebug"},
         {25, &IApplicationFunctions::ExtendSaveData, "ExtendSaveData"},
         {26, &IApplicationFunctions::GetSaveDataSize, "GetSaveDataSize"},
-        {27, nullptr, "CreateCacheStorage"},
+        {27, &IApplicationFunctions::CreateCacheStorage, "CreateCacheStorage"},
         {28, nullptr, "GetSaveDataSizeMax"},
         {29, nullptr, "GetCacheStorageMax"},
         {30, &IApplicationFunctions::BeginBlockingHomeButtonShortAndLongPressed, "BeginBlockingHomeButtonShortAndLongPressed"},
@@ -1738,6 +1739,36 @@ void IApplicationFunctions::GetSaveDataSize(HLERequestContext& ctx) {
     rb.Push(size.journal);
 }
 
+void IApplicationFunctions::CreateCacheStorage(HLERequestContext& ctx) {
+    struct InputParameters {
+        u16 index;
+        s64 size;
+        s64 journal_size;
+    };
+    static_assert(sizeof(InputParameters) == 24);
+
+    struct OutputParameters {
+        u32 storage_target;
+        u64 required_size;
+    };
+    static_assert(sizeof(OutputParameters) == 16);
+
+    IPC::RequestParser rp{ctx};
+    const auto params = rp.PopRaw<InputParameters>();
+
+    LOG_WARNING(Service_AM, "(STUBBED) called with index={}, size={:#x}, journal_size={:#x}",
+                params.index, params.size, params.journal_size);
+
+    const OutputParameters resp{
+        .storage_target = 1,
+        .required_size = 0,
+    };
+
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(resp);
+}
+
 void IApplicationFunctions::QueryApplicationPlayStatistics(HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 

src/core/hle/service/am/am.h

@@ -333,6 +333,7 @@ private:
     void GetPseudoDeviceId(HLERequestContext& ctx);
     void ExtendSaveData(HLERequestContext& ctx);
     void GetSaveDataSize(HLERequestContext& ctx);
+    void CreateCacheStorage(HLERequestContext& ctx);
     void BeginBlockingHomeButtonShortAndLongPressed(HLERequestContext& ctx);
     void EndBlockingHomeButtonShortAndLongPressed(HLERequestContext& ctx);
     void BeginBlockingHomeButton(HLERequestContext& ctx);

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -24,8 +24,10 @@
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/system_archive/system_archive.h"
 #include "core/file_sys/vfs.h"
+#include "core/hle/result.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
+#include "core/hle/service/hle_ipc.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/reporter.h"
 
@@ -552,9 +554,9 @@ public:
         // Write the data to memory
         ctx.WriteBuffer(begin, range_size);
 
-        IPC::ResponseBuilder rb{ctx, 3};
+        IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(ResultSuccess);
-        rb.Push<u32>(static_cast<u32>(actual_entries));
+        rb.Push<u64>(actual_entries);
     }
 
 private:
@@ -712,7 +714,7 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {59, nullptr, "WriteSaveDataFileSystemExtraData"},
         {60, nullptr, "OpenSaveDataInfoReader"},
         {61, &FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId, "OpenSaveDataInfoReaderBySaveDataSpaceId"},
-        {62, nullptr, "OpenCacheStorageList"},
+        {62, &FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage, "OpenSaveDataInfoReaderOnlyCacheStorage"},
         {64, nullptr, "OpenSaveDataInternalStorageFileSystem"},
         {65, nullptr, "UpdateSaveDataMacForDebug"},
         {66, nullptr, "WriteSaveDataFileSystemExtraData2"},
@@ -921,6 +923,15 @@ void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(HLERequestContext& ctx) {
         std::make_shared<ISaveDataInfoReader>(system, space, fsc));
 }
 
+void FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage(HLERequestContext& ctx) {
+    LOG_WARNING(Service_FS, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<ISaveDataInfoReader>(system, FileSys::SaveDataSpaceId::TemporaryStorage,
+                                             fsc);
+}
+
 void FSP_SRV::WriteSaveDataFileSystemExtraDataBySaveDataAttribute(HLERequestContext& ctx) {
     LOG_WARNING(Service_FS, "(STUBBED) called.");
 

src/core/hle/service/filesystem/fsp_srv.h

@@ -42,6 +42,7 @@ private:
     void OpenSaveDataFileSystem(HLERequestContext& ctx);
     void OpenReadOnlySaveDataFileSystem(HLERequestContext& ctx);
     void OpenSaveDataInfoReaderBySaveDataSpaceId(HLERequestContext& ctx);
+    void OpenSaveDataInfoReaderOnlyCacheStorage(HLERequestContext& ctx);
     void WriteSaveDataFileSystemExtraDataBySaveDataAttribute(HLERequestContext& ctx);
     void ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(HLERequestContext& ctx);
     void OpenDataStorageByCurrentProcess(HLERequestContext& ctx);

src/core/hle/service/nvnflinger/buffer_queue_producer.cpp

@@ -793,6 +793,7 @@ Status BufferQueueProducer::SetPreallocatedBuffer(s32 slot,
     std::scoped_lock lock{core->mutex};
 
     slots[slot] = {};
+    slots[slot].fence = Fence::NoFence();
     slots[slot].graphic_buffer = buffer;
     slots[slot].frame_number = 0;
 
@@ -854,7 +855,7 @@ void BufferQueueProducer::Transact(HLERequestContext& ctx, TransactionId code, u
         status = DequeueBuffer(&slot, &fence, is_async, width, height, pixel_format, usage);
 
         parcel_out.Write(slot);
-        parcel_out.WriteObject(&fence);
+        parcel_out.WriteFlattenedObject(&fence);
         break;
     }
     case TransactionId::RequestBuffer: {
@@ -864,7 +865,7 @@ void BufferQueueProducer::Transact(HLERequestContext& ctx, TransactionId code, u
 
         status = RequestBuffer(slot, &buf);
 
-        parcel_out.WriteObject(buf);
+        parcel_out.WriteFlattenedObject(buf);
         break;
     }
     case TransactionId::QueueBuffer: {

src/core/hle/service/nvnflinger/parcel.h

@@ -117,61 +117,67 @@ private:
 
 class OutputParcel final {
 public:
-    static constexpr std::size_t DefaultBufferSize = 0x40;
+    OutputParcel() = default;
-
-    OutputParcel() : buffer(DefaultBufferSize) {}
-
-    template <typename T>
-    explicit OutputParcel(const T& out_data) : buffer(DefaultBufferSize) {
-        Write(out_data);
-    }
 
     template <typename T>
     void Write(const T& val) {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
+        this->WriteImpl(val, m_data_buffer);
-
-        if (buffer.size() < write_index + sizeof(T)) {
-            buffer.resize(buffer.size() + sizeof(T) + DefaultBufferSize);
-        }
-
-        std::memcpy(buffer.data() + write_index, &val, sizeof(T));
-        write_index += sizeof(T);
-        write_index = Common::AlignUp(write_index, 4);
     }
 
     template <typename T>
-    void WriteObject(const T* ptr) {
+    void WriteFlattenedObject(const T* ptr) {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
-
         if (!ptr) {
-            Write<u32>(0);
+            this->Write<u32>(0);
             return;
         }
 
-        Write<u32>(1);
+        this->Write<u32>(1);
-        Write<s64>(sizeof(T));
+        this->Write<s64>(sizeof(T));
-        Write(*ptr);
+        this->Write(*ptr);
     }
 
     template <typename T>
-    void WriteObject(const std::shared_ptr<T> ptr) {
+    void WriteFlattenedObject(const std::shared_ptr<T> ptr) {
-        WriteObject(ptr.get());
+        this->WriteFlattenedObject(ptr.get());
+    }
+
+    template <typename T>
+    void WriteInterface(const T& val) {
+        this->WriteImpl(val, m_data_buffer);
+        this->WriteImpl(0U, m_object_buffer);
     }
 
     std::vector<u8> Serialize() const {
-        ParcelHeader header{};
+        std::vector<u8> output_buffer(sizeof(ParcelHeader) + m_data_buffer.size() +
-        header.data_size = static_cast<u32>(write_index - sizeof(ParcelHeader));
+                                      m_object_buffer.size());
-        header.data_offset = sizeof(ParcelHeader);
-        header.objects_size = 4;
-        header.objects_offset = static_cast<u32>(sizeof(ParcelHeader) + header.data_size);
-        std::memcpy(buffer.data(), &header, sizeof(ParcelHeader));
 
-        return buffer;
+        ParcelHeader header{};
+        header.data_size = static_cast<u32>(m_data_buffer.size());
+        header.data_offset = sizeof(ParcelHeader);
+        header.objects_size = static_cast<u32>(m_object_buffer.size());
+        header.objects_offset = header.data_offset + header.data_size;
+
+        std::memcpy(output_buffer.data(), &header, sizeof(header));
+        std::ranges::copy(m_data_buffer, output_buffer.data() + header.data_offset);
+        std::ranges::copy(m_object_buffer, output_buffer.data() + header.objects_offset);
+
+        return output_buffer;
     }
 
 private:
-    mutable std::vector<u8> buffer;
+    template <typename T>
-    std::size_t write_index = sizeof(ParcelHeader);
+        requires(std::is_trivially_copyable_v<T>)
+    void WriteImpl(const T& val, std::vector<u8>& buffer) {
+        const size_t aligned_size = Common::AlignUp(sizeof(T), 4);
+        const size_t old_size = buffer.size();
+        buffer.resize(old_size + aligned_size);
+
+        std::memcpy(buffer.data() + old_size, &val, sizeof(T));
+    }
+
+private:
+    std::vector<u8> m_data_buffer;
+    std::vector<u8> m_object_buffer;
 };
 
 } // namespace Service::android

src/core/hle/service/vi/vi.cpp

@@ -64,8 +64,8 @@ public:
 private:
     const u32 magic = 2;
     const u32 process_id = 1;
-    const u32 id;
+    const u64 id;
-    INSERT_PADDING_WORDS(3);
+    INSERT_PADDING_WORDS(2);
     std::array<u8, 8> dispdrv = {'d', 'i', 's', 'p', 'd', 'r', 'v', '\0'};
     INSERT_PADDING_WORDS(2);
 };
@@ -608,7 +608,9 @@ private:
             return;
         }
 
-        const auto parcel = android::OutputParcel{NativeWindow{*buffer_queue_id}};
+        android::OutputParcel parcel;
+        parcel.WriteInterface(NativeWindow{*buffer_queue_id});
+
         const auto buffer_size = ctx.WriteBuffer(parcel.Serialize());
 
         IPC::ResponseBuilder rb{ctx, 4};
@@ -654,7 +656,9 @@ private:
             return;
         }
 
-        const auto parcel = android::OutputParcel{NativeWindow{*buffer_queue_id}};
+        android::OutputParcel parcel;
+        parcel.WriteInterface(NativeWindow{*buffer_queue_id});
+
         const auto buffer_size = ctx.WriteBuffer(parcel.Serialize());
 
         IPC::ResponseBuilder rb{ctx, 6};