summaryrefslogtreecommitdiff
path: root/src/audio_core/info_updater.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/audio_core/info_updater.cpp')
-rw-r--r--src/audio_core/info_updater.cpp511
1 files changed, 0 insertions, 511 deletions
diff --git a/src/audio_core/info_updater.cpp b/src/audio_core/info_updater.cpp
deleted file mode 100644
index 0065e6e53..000000000
--- a/src/audio_core/info_updater.cpp
+++ /dev/null
@@ -1,511 +0,0 @@
1// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
2// SPDX-License-Identifier: GPL-2.0-or-later
3
4#include "audio_core/behavior_info.h"
5#include "audio_core/effect_context.h"
6#include "audio_core/info_updater.h"
7#include "audio_core/memory_pool.h"
8#include "audio_core/mix_context.h"
9#include "audio_core/sink_context.h"
10#include "audio_core/splitter_context.h"
11#include "audio_core/voice_context.h"
12#include "common/logging/log.h"
13
14namespace AudioCore {
15
16InfoUpdater::InfoUpdater(const std::vector<u8>& in_params_, std::vector<u8>& out_params_,
17 BehaviorInfo& behavior_info_)
18 : in_params(in_params_), out_params(out_params_), behavior_info(behavior_info_) {
19 ASSERT(
20 AudioCommon::CanConsumeBuffer(in_params.size(), 0, sizeof(AudioCommon::UpdateDataHeader)));
21 std::memcpy(&input_header, in_params.data(), sizeof(AudioCommon::UpdateDataHeader));
22 output_header.total_size = sizeof(AudioCommon::UpdateDataHeader);
23}
24
25InfoUpdater::~InfoUpdater() = default;
26
27bool InfoUpdater::UpdateBehaviorInfo(BehaviorInfo& in_behavior_info) {
28 if (input_header.size.behavior != sizeof(BehaviorInfo::InParams)) {
29 LOG_ERROR(Audio, "Behavior info is an invalid size, expecting 0x{:X} but got 0x{:X}",
30 sizeof(BehaviorInfo::InParams), input_header.size.behavior);
31 return false;
32 }
33
34 if (!AudioCommon::CanConsumeBuffer(in_params.size(), input_offset,
35 sizeof(BehaviorInfo::InParams))) {
36 LOG_ERROR(Audio, "Buffer is an invalid size!");
37 return false;
38 }
39
40 BehaviorInfo::InParams behavior_in{};
41 std::memcpy(&behavior_in, in_params.data() + input_offset, sizeof(BehaviorInfo::InParams));
42 input_offset += sizeof(BehaviorInfo::InParams);
43
44 // Make sure it's an audio revision we can actually support
45 if (!AudioCommon::IsValidRevision(behavior_in.revision)) {
46 LOG_ERROR(Audio, "Invalid input revision, revision=0x{:08X}", behavior_in.revision);
47 return false;
48 }
49
50 // Make sure that our behavior info revision matches the input
51 if (in_behavior_info.GetUserRevision() != behavior_in.revision) {
52 LOG_ERROR(Audio,
53 "User revision differs from input revision, expecting 0x{:08X} but got 0x{:08X}",
54 in_behavior_info.GetUserRevision(), behavior_in.revision);
55 return false;
56 }
57
58 // Update behavior info flags
59 in_behavior_info.ClearError();
60 in_behavior_info.UpdateFlags(behavior_in.flags);
61
62 return true;
63}
64
65bool InfoUpdater::UpdateMemoryPools(std::vector<ServerMemoryPoolInfo>& memory_pool_info) {
66 const auto memory_pool_count = memory_pool_info.size();
67 const auto total_memory_pool_in = sizeof(ServerMemoryPoolInfo::InParams) * memory_pool_count;
68 const auto total_memory_pool_out = sizeof(ServerMemoryPoolInfo::OutParams) * memory_pool_count;
69
70 if (input_header.size.memory_pool != total_memory_pool_in) {
71 LOG_ERROR(Audio, "Memory pools are an invalid size, expecting 0x{:X} but got 0x{:X}",
72 total_memory_pool_in, input_header.size.memory_pool);
73 return false;
74 }
75
76 if (!AudioCommon::CanConsumeBuffer(in_params.size(), input_offset, total_memory_pool_in)) {
77 LOG_ERROR(Audio, "Buffer is an invalid size!");
78 return false;
79 }
80
81 std::vector<ServerMemoryPoolInfo::InParams> mempool_in(memory_pool_count);
82 std::vector<ServerMemoryPoolInfo::OutParams> mempool_out(memory_pool_count);
83
84 std::memcpy(mempool_in.data(), in_params.data() + input_offset, total_memory_pool_in);
85 input_offset += total_memory_pool_in;
86
87 // Update our memory pools
88 for (std::size_t i = 0; i < memory_pool_count; i++) {
89 if (!memory_pool_info[i].Update(mempool_in[i], mempool_out[i])) {
90 LOG_ERROR(Audio, "Failed to update memory pool {}!", i);
91 return false;
92 }
93 }
94
95 if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset,
96 sizeof(BehaviorInfo::InParams))) {
97 LOG_ERROR(Audio, "Buffer is an invalid size!");
98 return false;
99 }
100
101 std::memcpy(out_params.data() + output_offset, mempool_out.data(), total_memory_pool_out);
102 output_offset += total_memory_pool_out;
103 output_header.size.memory_pool = static_cast<u32>(total_memory_pool_out);
104 return true;
105}
106
107bool InfoUpdater::UpdateVoiceChannelResources(VoiceContext& voice_context) {
108 const auto voice_count = voice_context.GetVoiceCount();
109 const auto voice_size = voice_count * sizeof(VoiceChannelResource::InParams);
110 std::vector<VoiceChannelResource::InParams> resources_in(voice_count);
111
112 if (input_header.size.voice_channel_resource != voice_size) {
113 LOG_ERROR(Audio, "VoiceChannelResource is an invalid size, expecting 0x{:X} but got 0x{:X}",
114 voice_size, input_header.size.voice_channel_resource);
115 return false;
116 }
117
118 if (!AudioCommon::CanConsumeBuffer(in_params.size(), input_offset, voice_size)) {
119 LOG_ERROR(Audio, "Buffer is an invalid size!");
120 return false;
121 }
122
123 std::memcpy(resources_in.data(), in_params.data() + input_offset, voice_size);
124 input_offset += voice_size;
125
126 // Update our channel resources
127 for (std::size_t i = 0; i < voice_count; i++) {
128 // Grab our channel resource
129 auto& resource = voice_context.GetChannelResource(i);
130 resource.Update(resources_in[i]);
131 }
132
133 return true;
134}
135
136bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
137 [[maybe_unused]] std::vector<ServerMemoryPoolInfo>& memory_pool_info,
138 [[maybe_unused]] VAddr audio_codec_dsp_addr) {
139 const auto voice_count = voice_context.GetVoiceCount();
140 std::vector<VoiceInfo::InParams> voice_in(voice_count);
141 std::vector<VoiceInfo::OutParams> voice_out(voice_count);
142
143 const auto voice_in_size = voice_count * sizeof(VoiceInfo::InParams);
144 const auto voice_out_size = voice_count * sizeof(VoiceInfo::OutParams);
145
146 if (input_header.size.voice != voice_in_size) {
147 LOG_ERROR(Audio, "Voices are an invalid size, expecting 0x{:X} but got 0x{:X}",
148 voice_in_size, input_header.size.voice);
149 return false;
150 }
151
152 if (!AudioCommon::CanConsumeBuffer(in_params.size(), input_offset, voice_in_size)) {
153 LOG_ERROR(Audio, "Buffer is an invalid size!");
154 return false;
155 }
156
157 std::memcpy(voice_in.data(), in_params.data() + input_offset, voice_in_size);
158 input_offset += voice_in_size;
159
160 // Set all voices to not be in use
161 for (std::size_t i = 0; i < voice_count; i++) {
162 voice_context.GetInfo(i).GetInParams().in_use = false;
163 }
164
165 // Update our voices
166 for (std::size_t i = 0; i < voice_count; i++) {
167 auto& voice_in_params = voice_in[i];
168 const auto channel_count = static_cast<std::size_t>(voice_in_params.channel_count);
169 // Skip if it's not currently in use
170 if (!voice_in_params.is_in_use) {
171 continue;
172 }
173 // Voice states for each channel
174 std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT> voice_states{};
175 ASSERT(static_cast<std::size_t>(voice_in_params.id) < voice_count);
176
177 // Grab our current voice info
178 auto& voice_info = voice_context.GetInfo(static_cast<std::size_t>(voice_in_params.id));
179
180 ASSERT(channel_count <= AudioCommon::MAX_CHANNEL_COUNT);
181
182 // Get all our channel voice states
183 for (std::size_t channel = 0; channel < channel_count; channel++) {
184 voice_states[channel] =
185 &voice_context.GetState(voice_in_params.voice_channel_resource_ids[channel]);
186 }
187
188 if (voice_in_params.is_new) {
189 // Default our values for our voice
190 voice_info.Initialize();
191
192 // Zero out our voice states
193 for (std::size_t channel = 0; channel < channel_count; channel++) {
194 std::memset(voice_states[channel], 0, sizeof(VoiceState));
195 }
196 }
197
198 // Update our voice
199 voice_info.UpdateParameters(voice_in_params, behavior_info);
200 // TODO(ogniK): Handle mapping errors with behavior info based on in params response
201
202 // Update our wave buffers
203 voice_info.UpdateWaveBuffers(voice_in_params, voice_states, behavior_info);
204 voice_info.WriteOutStatus(voice_out[i], voice_in_params, voice_states);
205 }
206
207 if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset, voice_out_size)) {
208 LOG_ERROR(Audio, "Buffer is an invalid size!");
209 return false;
210 }
211 std::memcpy(out_params.data() + output_offset, voice_out.data(), voice_out_size);
212 output_offset += voice_out_size;
213 output_header.size.voice = static_cast<u32>(voice_out_size);
214 return true;
215}
216
217bool InfoUpdater::UpdateEffects(EffectContext& effect_context, bool is_active) {
218 const auto effect_count = effect_context.GetCount();
219 std::vector<EffectInfo::InParams> effect_in(effect_count);
220 std::vector<EffectInfo::OutParams> effect_out(effect_count);
221
222 const auto total_effect_in = effect_count * sizeof(EffectInfo::InParams);
223 const auto total_effect_out = effect_count * sizeof(EffectInfo::OutParams);
224
225 if (input_header.size.effect != total_effect_in) {
226 LOG_ERROR(Audio, "Effects are an invalid size, expecting 0x{:X} but got 0x{:X}",
227 total_effect_in, input_header.size.effect);
228 return false;
229 }
230
231 if (!AudioCommon::CanConsumeBuffer(in_params.size(), input_offset, total_effect_in)) {
232 LOG_ERROR(Audio, "Buffer is an invalid size!");
233 return false;
234 }
235
236 std::memcpy(effect_in.data(), in_params.data() + input_offset, total_effect_in);
237 input_offset += total_effect_in;
238
239 // Update effects
240 for (std::size_t i = 0; i < effect_count; i++) {
241 auto* info = effect_context.GetInfo(i);
242 if (effect_in[i].type != info->GetType()) {
243 info = effect_context.RetargetEffect(i, effect_in[i].type);
244 }
245
246 info->Update(effect_in[i]);
247
248 if ((!is_active && info->GetUsage() != UsageState::Initialized) ||
249 info->GetUsage() == UsageState::Stopped) {
250 effect_out[i].status = UsageStatus::Removed;
251 } else {
252 effect_out[i].status = UsageStatus::Used;
253 }
254 }
255
256 if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset, total_effect_out)) {
257 LOG_ERROR(Audio, "Buffer is an invalid size!");
258 return false;
259 }
260
261 std::memcpy(out_params.data() + output_offset, effect_out.data(), total_effect_out);
262 output_offset += total_effect_out;
263 output_header.size.effect = static_cast<u32>(total_effect_out);
264
265 return true;
266}
267
268bool InfoUpdater::UpdateSplitterInfo(SplitterContext& splitter_context) {
269 std::size_t start_offset = input_offset;
270 std::size_t bytes_read{};
271 // Update splitter context
272 if (!splitter_context.Update(in_params, input_offset, bytes_read)) {
273 LOG_ERROR(Audio, "Failed to update splitter context!");
274 return false;
275 }
276
277 const auto consumed = input_offset - start_offset;
278
279 if (input_header.size.splitter != consumed) {
280 LOG_ERROR(Audio, "Splitters is an invalid size, expecting 0x{:X} but got 0x{:X}",
281 bytes_read, input_header.size.splitter);
282 return false;
283 }
284
285 return true;
286}
287
288Result InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buffer_count,
289 SplitterContext& splitter_context, EffectContext& effect_context) {
290 std::vector<MixInfo::InParams> mix_in_params;
291
292 if (!behavior_info.IsMixInParameterDirtyOnlyUpdateSupported()) {
293 // If we're not dirty, get ALL mix in parameters
294 const auto context_mix_count = mix_context.GetCount();
295 const auto total_mix_in = context_mix_count * sizeof(MixInfo::InParams);
296 if (input_header.size.mixer != total_mix_in) {
297 LOG_ERROR(Audio, "Mixer is an invalid size, expecting 0x{:X} but got 0x{:X}",
298 total_mix_in, input_header.size.mixer);
299 return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
300 }
301
302 if (!AudioCommon::CanConsumeBuffer(in_params.size(), input_offset, total_mix_in)) {
303 LOG_ERROR(Audio, "Buffer is an invalid size!");
304 return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
305 }
306
307 mix_in_params.resize(context_mix_count);
308 std::memcpy(mix_in_params.data(), in_params.data() + input_offset, total_mix_in);
309
310 input_offset += total_mix_in;
311 } else {
312 // Only update the "dirty" mixes
313 MixInfo::DirtyHeader dirty_header{};
314 if (!AudioCommon::CanConsumeBuffer(in_params.size(), input_offset,
315 sizeof(MixInfo::DirtyHeader))) {
316 LOG_ERROR(Audio, "Buffer is an invalid size!");
317 return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
318 }
319
320 std::memcpy(&dirty_header, in_params.data() + input_offset, sizeof(MixInfo::DirtyHeader));
321 input_offset += sizeof(MixInfo::DirtyHeader);
322
323 const auto total_mix_in =
324 dirty_header.mixer_count * sizeof(MixInfo::InParams) + sizeof(MixInfo::DirtyHeader);
325
326 if (input_header.size.mixer != total_mix_in) {
327 LOG_ERROR(Audio, "Mixer is an invalid size, expecting 0x{:X} but got 0x{:X}",
328 total_mix_in, input_header.size.mixer);
329 return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
330 }
331
332 if (dirty_header.mixer_count != 0) {
333 mix_in_params.resize(dirty_header.mixer_count);
334 std::memcpy(mix_in_params.data(), in_params.data() + input_offset,
335 mix_in_params.size() * sizeof(MixInfo::InParams));
336 input_offset += mix_in_params.size() * sizeof(MixInfo::InParams);
337 }
338 }
339
340 // Get our total input count
341 const auto mix_count = mix_in_params.size();
342
343 if (!behavior_info.IsMixInParameterDirtyOnlyUpdateSupported()) {
344 // Only verify our buffer count if we're not dirty
345 std::size_t total_buffer_count{};
346 for (std::size_t i = 0; i < mix_count; i++) {
347 const auto& in = mix_in_params[i];
348 total_buffer_count += in.buffer_count;
349 if (static_cast<std::size_t>(in.dest_mix_id) > mix_count &&
350 in.dest_mix_id != AudioCommon::NO_MIX && in.mix_id != AudioCommon::FINAL_MIX) {
351 LOG_ERROR(
352 Audio,
353 "Invalid mix destination, mix_id={:X}, dest_mix_id={:X}, mix_buffer_count={:X}",
354 in.mix_id, in.dest_mix_id, mix_buffer_count);
355 return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
356 }
357 }
358
359 if (total_buffer_count > mix_buffer_count) {
360 LOG_ERROR(Audio,
361 "Too many mix buffers used! mix_buffer_count={:X}, requesting_buffers={:X}",
362 mix_buffer_count, total_buffer_count);
363 return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
364 }
365 }
366
367 if (mix_buffer_count == 0) {
368 LOG_ERROR(Audio, "No mix buffers!");
369 return AudioCommon::Audren::ERR_INVALID_PARAMETERS;
370 }
371
372 bool should_sort = false;
373 for (std::size_t i = 0; i < mix_count; i++) {
374 const auto& mix_in = mix_in_params[i];
375 std::size_t target_mix{};
376 if (behavior_info.IsMixInParameterDirtyOnlyUpdateSupported()) {
377 target_mix = mix_in.mix_id;
378 } else {
379 // Non dirty supported games just use i instead of the actual mix_id
380 target_mix = i;
381 }
382 auto& mix_info = mix_context.GetInfo(target_mix);
383 auto& mix_info_params = mix_info.GetInParams();
384 if (mix_info_params.in_use != mix_in.in_use) {
385 mix_info_params.in_use = mix_in.in_use;
386 mix_info.ResetEffectProcessingOrder();
387 should_sort = true;
388 }
389
390 if (mix_in.in_use) {
391 should_sort |= mix_info.Update(mix_context.GetEdgeMatrix(), mix_in, behavior_info,
392 splitter_context, effect_context);
393 }
394 }
395
396 if (should_sort && behavior_info.IsSplitterSupported()) {
397 // Sort our splitter data
398 if (!mix_context.TsortInfo(splitter_context)) {
399 return AudioCommon::Audren::ERR_SPLITTER_SORT_FAILED;
400 }
401 }
402
403 // TODO(ogniK): Sort when splitter is suppoorted
404
405 return ResultSuccess;
406}
407
408bool InfoUpdater::UpdateSinks(SinkContext& sink_context) {
409 const auto sink_count = sink_context.GetCount();
410 std::vector<SinkInfo::InParams> sink_in_params(sink_count);
411 const auto total_sink_in = sink_count * sizeof(SinkInfo::InParams);
412
413 if (input_header.size.sink != total_sink_in) {
414 LOG_ERROR(Audio, "Sinks are an invalid size, expecting 0x{:X} but got 0x{:X}",
415 total_sink_in, input_header.size.effect);
416 return false;
417 }
418
419 if (!AudioCommon::CanConsumeBuffer(in_params.size(), input_offset, total_sink_in)) {
420 LOG_ERROR(Audio, "Buffer is an invalid size!");
421 return false;
422 }
423
424 std::memcpy(sink_in_params.data(), in_params.data() + input_offset, total_sink_in);
425 input_offset += total_sink_in;
426
427 // TODO(ogniK): Properly update sinks
428 if (!sink_in_params.empty()) {
429 sink_context.UpdateMainSink(sink_in_params[0]);
430 }
431
432 output_header.size.sink = static_cast<u32>(0x20 * sink_count);
433 output_offset += 0x20 * sink_count;
434 return true;
435}
436
437bool InfoUpdater::UpdatePerformanceBuffer() {
438 output_header.size.performance = 0x10;
439 output_offset += 0x10;
440 return true;
441}
442
443bool InfoUpdater::UpdateErrorInfo([[maybe_unused]] BehaviorInfo& in_behavior_info) {
444 const auto total_beahvior_info_out = sizeof(BehaviorInfo::OutParams);
445
446 if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset, total_beahvior_info_out)) {
447 LOG_ERROR(Audio, "Buffer is an invalid size!");
448 return false;
449 }
450
451 BehaviorInfo::OutParams behavior_info_out{};
452 behavior_info.CopyErrorInfo(behavior_info_out);
453
454 std::memcpy(out_params.data() + output_offset, &behavior_info_out, total_beahvior_info_out);
455 output_offset += total_beahvior_info_out;
456 output_header.size.behavior = total_beahvior_info_out;
457
458 return true;
459}
460
461struct RendererInfo {
462 u64_le elasped_frame_count{};
463 INSERT_PADDING_WORDS(2);
464};
465static_assert(sizeof(RendererInfo) == 0x10, "RendererInfo is an invalid size");
466
467bool InfoUpdater::UpdateRendererInfo(std::size_t elapsed_frame_count) {
468 const auto total_renderer_info_out = sizeof(RendererInfo);
469 if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset, total_renderer_info_out)) {
470 LOG_ERROR(Audio, "Buffer is an invalid size!");
471 return false;
472 }
473 RendererInfo out{};
474 out.elasped_frame_count = elapsed_frame_count;
475 std::memcpy(out_params.data() + output_offset, &out, total_renderer_info_out);
476 output_offset += total_renderer_info_out;
477 output_header.size.render_info = total_renderer_info_out;
478
479 return true;
480}
481
482bool InfoUpdater::CheckConsumedSize() const {
483 if (output_offset != out_params.size()) {
484 LOG_ERROR(Audio, "Output is not consumed! Consumed {}, but requires {}. {} bytes remaining",
485 output_offset, out_params.size(), out_params.size() - output_offset);
486 return false;
487 }
488 /*if (input_offset != in_params.size()) {
489 LOG_ERROR(Audio, "Input is not consumed!");
490 return false;
491 }*/
492 return true;
493}
494
495bool InfoUpdater::WriteOutputHeader() {
496 if (!AudioCommon::CanConsumeBuffer(out_params.size(), 0,
497 sizeof(AudioCommon::UpdateDataHeader))) {
498 LOG_ERROR(Audio, "Buffer is an invalid size!");
499 return false;
500 }
501 output_header.revision = AudioCommon::CURRENT_PROCESS_REVISION;
502 const auto& sz = output_header.size;
503 output_header.total_size += sz.behavior + sz.memory_pool + sz.voice +
504 sz.voice_channel_resource + sz.effect + sz.mixer + sz.sink +
505 sz.performance + sz.splitter + sz.render_info;
506
507 std::memcpy(out_params.data(), &output_header, sizeof(AudioCommon::UpdateDataHeader));
508 return true;
509}
510
511} // namespace AudioCore
HIC SVNT DRACONES