Removed duplicate structs, changed AudioRendererResponse -> UpdateDataHeader

According to game symbols(SMO), there's references to UpdateDataHeader which seems to be what AudioRendererResponse actually is

src/core/hle/service/audio/audren_u.cpp

@@ -58,22 +58,22 @@ private:
     }
 
     void RequestUpdateAudioRenderer(Kernel::HLERequestContext& ctx) {
-        AudioRendererConfig config;
+        UpdateDataHeader config{};
         auto buf = ctx.ReadBuffer();
-        std::memcpy(&config, buf.data(), sizeof(AudioRendererConfig));
+        std::memcpy(&config, buf.data(), sizeof(UpdateDataHeader));
         u32 memory_pool_count = worker_params.effect_count + (worker_params.voice_count * 4);
 
         std::vector<MemoryPoolInfo> mem_pool_info(memory_pool_count);
         std::memcpy(mem_pool_info.data(),
-                    buf.data() + sizeof(AudioRendererConfig) + config.behavior_size,
+                    buf.data() + sizeof(UpdateDataHeader) + config.behavior_size,
                     memory_pool_count * sizeof(MemoryPoolInfo));
 
-        AudioRendererResponse response_data{worker_params};
+        UpdateDataHeader response_data{worker_params};
 
         ASSERT(ctx.GetWriteBufferSize() == response_data.total_size);
 
         std::vector<u8> output(response_data.total_size);
-        std::memcpy(output.data(), &response_data, sizeof(AudioRendererResponse));
+        std::memcpy(output.data(), &response_data, sizeof(UpdateDataHeader));
         std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
         for (unsigned i = 0; i < memory_pool.size(); i++) {
             if (mem_pool_info[i].pool_state == MemoryPoolStates::RequestAttach)
@@ -83,7 +83,7 @@ private:
             else
                 memory_pool[i].state = mem_pool_info[i].pool_state;
         }
-        std::memcpy(output.data() + sizeof(AudioRendererResponse), memory_pool.data(),
+        std::memcpy(output.data() + sizeof(UpdateDataHeader), memory_pool.data(),
                     response_data.memory_pools_size);
 
         ctx.WriteBuffer(output);
@@ -146,47 +146,34 @@ private:
     };
     static_assert(sizeof(MemoryPoolInfo) == 0x20, "MemoryPoolInfo has wrong size");
 
-    struct AudioRendererConfig {
+    struct UpdateDataHeader {
-        u32 revision;
+        UpdateDataHeader() {}
-        u32 behavior_size;
-        u32 memory_pools_size;
-        u32 voices_size;
-        u32 voice_resource_size;
-        u32 effects_size;
-        u32 mixes_size;
-        u32 sinks_size;
-        u32 performance_buffer_size;
-        INSERT_PADDING_WORDS(6);
-        u32 total_size;
-    };
-    static_assert(sizeof(AudioRendererConfig) == 0x40, "AudioRendererConfig has wrong size");
 
-    struct AudioRendererResponse {
+        UpdateDataHeader(const AudioRendererParameters& config) {
-        AudioRendererResponse(const AudioRendererParameters& config) {
             revision = config.revision;
-            error_info_size = 0xb0;
+            behavior_size = 0xb0;
             memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
             voices_size = config.voice_count * 0x10;
             effects_size = config.effect_count * 0x10;
             sinks_size = config.sink_count * 0x20;
             performance_manager_size = 0x10;
-            total_size = sizeof(AudioRendererResponse) + error_info_size + memory_pools_size +
+            total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size +
                          voices_size + effects_size + sinks_size + performance_manager_size;
         }
 
         u32_le revision;
-        u32_le error_info_size;
+        u32_le behavior_size;
         u32_le memory_pools_size;
         u32_le voices_size;
-        u32_le unknown_10;
+        u32_le voice_resource_size;
         u32_le effects_size;
-        u32_le unknown_18;
+        u32_le mixes_size;
         u32_le sinks_size;
         u32_le performance_manager_size;
         INSERT_PADDING_WORDS(6);
         u32_le total_size;
     };
-    static_assert(sizeof(AudioRendererResponse) == 0x40, "AudioRendererResponse has wrong size");
+    static_assert(sizeof(UpdateDataHeader) == 0x40, "AudioRendererResponse has wrong size");
 
     /// This is used to trigger the audio event callback.
     CoreTiming::EventType* audio_event;