. .ci/scripts/common/pre-upload.sh

ARCHIVE_NAME="${REV_NAME}.tar.xz"

COMPRESSION_FLAGS="-cJvf"

else

fi

mkdir "$DIR_NAME"

cp build/bin/yuzu-cmd "$DIR_NAME"

# Build an AppImage

cd build

export APPIMAGE_EXTRACT_AND_RUN=1

fi

if [ "${RELEASE_NAME}" = "mainline" ]; then

# Generate update information if releasing to mainline

./appimagetool-x86_64.AppImage -u "gh-releases-zsync|yuzu-emu|yuzu-${RELEASE_NAME}|latest|yuzu-*.AppImage.zsync" AppDir "${APPIMAGE_NAME}"

cp "build/${APPIMAGE_NAME}.zsync" "${ARTIFACTS_DIR}/"

fi

. .ci/scripts/common/post-upload.sh

- stage: build

displayName: 'build'

jobs:

timeoutInMinutes: 120

pool:

vmImage: windows-2022

steps:

dist/icons/controller/*.png

dist/icons/overlay/*.png

dist/languages/*

dist/qt_themes/*/icons/index.theme

dist/qt_themes/default/style.qss

Copyright: yuzu Emulator Project

Copyright: Ionic (http://ionic.io/)

License: MIT

dist/qt_themes/default/icons/16x16/checked.png

dist/qt_themes/default/icons/16x16/failed.png

Copyright: SVG Repo

# Dynarmic

if (ARCHITECTURE_x86_64)

set(DYNARMIC_NO_BUNDLED_FMT ON)

set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)

add_subdirectory(dynarmic)

sink/sink.h

sink/sink_details.cpp

sink/sink_details.h

sink/sink_stream.h

)

return *adsp;

}

}

}

} // namespace AudioCore

class AudioManager;

/**

*/

class AudioCore {

public:

AudioRenderer::ADSP::ADSP& GetADSP();

/**

*

*/

/**

*/

private:

/**

std::unique_ptr<Sink::Sink> input_sink;

/// The ADSP in the sysmodule

std::unique_ptr<AudioRenderer::ADSP::ADSP> adsp;

};

} // namespace AudioCore

* Responsible for the input/output events, set by the stream backend when buffers are consumed, and

* waited on by the audio manager. These callbacks signal the game's events to keep the audio buffer

* recycling going.

* On the Switch it's implemented more simply through a MultiWaitEventHolder, where it can

* wait on multiple events at once, and the events are not needed by the backend.

*/

void ClearEvents();

private:

std::mutex event_lock;

/// Array of events, one per system type (see Type), last event is used to terminate

std::array<std::atomic<bool>, 4> events_signalled;

auto input_devices{Sink::GetDeviceListForSink(Settings::values.sink_id.GetValue(), true)};

if (input_devices.size() > 1) {

return 1;

}

return 0;

/**

* Get a list of audio in device names.

*

* @param filter - Should the list be filtered? Unused.

* @return Number of names written.

*/

u32 GetDeviceNames(std::vector<AudioRenderer::AudioDevice::AudioDeviceName>& names,

private:

/**

*/

void ThreadFunc();

u32 Manager::GetAudioOutDeviceNames(

std::vector<AudioRenderer::AudioDevice::AudioDeviceName>& names) const {

return 1;

}

/**

* Add a renderer system to the manager.

*

* @param system - The system to add.

*/

bool AddSystem(System& system);

* Remove a renderer system from the manager.

*

* @param system - The system to remove.

*/

bool RemoveSystem(System& system);

namespace AudioCore {

struct AudioBuffer {

/// Timestamp this buffer completed playing.

s64 played_timestamp;

/// Game memory address for these samples.

if (index < 0) {

index += N;

}

out_buffers.push_back(buffers[index]);

registered_count++;

registered_index = (registered_index + 1) % append_limit;

/**

* Release all registered buffers.

*

* @return Is the buffer was released.

*/

bool ReleaseBuffers(Core::Timing::CoreTiming& core_timing, DeviceSession& session) {

}

// Check with the backend if this buffer can be released yet.

break;

}

return true;

}

private:

/// Buffer lock

mutable std::recursive_mutex lock{};

#include "audio_core/device/device_session.h"

#include "audio_core/sink/sink_stream.h"

#include "core/core.h"

#include "core/memory.h"

namespace AudioCore {

DeviceSession::~DeviceSession() {

Finalize();

}

void DeviceSession::Start() {

}

void DeviceSession::Stop() {

if (stream) {

stream->Stop();

}

}

void DeviceSession::AppendBuffers(std::span<AudioBuffer> buffers) const {

for (size_t i = 0; i < buffers.size(); i++) {

Sink::SinkBuffer new_buffer{

.frames = buffers[i].size / (channel_count * sizeof(s16)),

stream->AppendBuffer(new_buffer, samples);

} else {

std::vector<s16> samples(buffers[i].size / sizeof(s16));

stream->AppendBuffer(new_buffer, samples);

}

}

void DeviceSession::ReleaseBuffer(AudioBuffer& buffer) const {

if (type == Sink::StreamType::In) {

auto samples{stream->ReleaseBuffer(buffer.size / sizeof(s16))};

}

}

}

void DeviceSession::SetVolume(f32 volume) const {

}

u64 DeviceSession::GetPlayedSampleCount() const {

}

}

} // namespace AudioCore

#pragma once

#include <span>

#include "audio_core/common/common.h"

namespace Core {

class System;

namespace AudioCore {

namespace Sink {

class SinkStream;

struct SinkBuffer;

/**

* Check if the buffer for the given tag has been consumed by the backend.

*

* @return true if the buffer has been consumed, otherwise false.

*/

/**

* Start this device session, starting the backend stream.

*/

u64 GetPlayedSampleCount() const;

private:

/// System

Core::System& system;

/// Applet resource user id of this device session

u64 applet_resource_user_id{};

/// Total number of samples played by this device session

/// Is this session initialised?

bool initialized{};

};

} // namespace AudioCore

std::vector<AudioBuffer> buffers_to_flush{};

buffers.RegisterBuffers(buffers_to_flush);

session->AppendBuffers(buffers_to_flush);

return ResultSuccess;

}

return false;

}

buffers.AppendBuffer(new_buffer);

RegisterBuffers();

/**

* Set this system's current volume.

*

*/

void SetVolume(f32 volume);

std::vector<AudioBuffer> buffers_to_flush{};

buffers.RegisterBuffers(buffers_to_flush);

session->AppendBuffers(buffers_to_flush);

return ResultSuccess;

}

return false;

}

buffers.AppendBuffer(new_buffer);

RegisterBuffers();

/**

* Set this system's current volume.

*

*/

void SetVolume(f32 volume);

/**

* Stop the ADSP.

*/

void Stop();

mailbox = mailbox_;

thread = std::thread(&AudioRenderer::ThreadFunc, this);

running = true;

}

std::string name{fmt::format("ADSP_RenderStream-{}", i)};

streams[i] =

sink.AcquireSinkStream(system, channels, name, ::AudioCore::Sink::StreamType::Render);

}

}

command_list_processor.Process(index) - start_time;

}

const auto end_time{system.CoreTiming().GetClockTicks()};

command_buffer.remaining_command_count =

/**

* Send a message from the host to the AudioRenderer.

*

*/

void HostSendMessage(RenderMessage message);

/**

* Send a message from the AudioRenderer to the host.

*

*/

void ADSPSendMessage(RenderMessage message);

/**

* Start the AudioRenderer.

*

*/

void Start(AudioRenderer_Mailbox* mailbox);

/**

* Initialize the processor.

*

*/

void Initialize(Core::System& system, CpuAddr buffer, u64 size, Sink::SinkStream* stream);

/**

* Process the command list.

*

* @return The time taken to process.

*/

u64 Process(u32 session_id);

u8* commands{};

/// The command buffer size

u64 commands_buffer_size{};

u64 max_process_time{};

/// The number of commands in the buffer

u32 command_count{};

// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project

// SPDX-License-Identifier: GPL-2.0-or-later

#include "audio_core/audio_core.h"

#include "audio_core/common/feature_support.h"

#include "audio_core/renderer/audio_device.h"

namespace AudioCore::AudioRenderer {

AudioDevice::AudioDevice(Core::System& system, const u64 applet_resource_user_id_,

const u32 revision)

: output_sink{system.AudioCore().GetOutputSink()},

applet_resource_user_id{applet_resource_user_id_}, user_revision{revision} {}

u32 AudioDevice::ListAudioDeviceName(std::vector<AudioDeviceName>& out_buffer,

if (CheckFeatureSupported(SupportTags::AudioUsbDeviceOutput, user_revision)) {

names = usb_device_names;

names = device_names;

}

for (u32 i = 0; i < out_count; i++) {

out_buffer.push_back(names[i]);

}

}

u32 AudioDevice::ListAudioOutputDeviceName(std::vector<AudioDeviceName>& out_buffer,

for (u32 i = 0; i < out_count; i++) {

out_buffer.push_back(output_device_names[i]);

output_sink.SetDeviceVolume(volume);

}

return output_sink.GetDeviceVolume();

}

#pragma once

#include "audio_core/audio_render_manager.h"

class AudioDevice {

public:

struct AudioDeviceName {

}

};

explicit AudioDevice(Core::System& system, u64 applet_resource_user_id, u32 revision);

/**

* @param max_count - Maximum number of devices to write (count of out_buffer).

* @return Number of device names written.

*/

/**

* Get a list of the available output devices.

* @param max_count - Maximum number of devices to write (count of out_buffer).

* @return Number of device names written.

*/

/**

* Set the volume of all streams in the backend sink.

* @param name - Name of the device to check. Unused.

* @return Volume of the device.

*/

private:

/// Backend output sink for the device

}

void BehaviorInfo::CopyErrorInfo(std::span<ErrorInfo> out_errors, u32& out_count) {

}

}

void BehaviorInfo::UpdateFlags(const Flags flags_) {

* @param volume - Current mix volume used for calculating the ramp.

* @param prev_volume - Previous mix volume, used for calculating the ramp,

* also applied to the input.

* @param precision - Number of decimal bits for fixed point operations.

*/

void GenerateMixRampCommand(s32 node_id, s16 buffer_count, s16 input_index, s16 output_index,

* @param volumes - Current mix volumes used for calculating the ramp.

* @param prev_volumes - Previous mix volumes, used for calculating the ramp,

* also applied to the input.

* @param precision - Number of decimal bits for fixed point operations.

*/

void GenerateMixRampGroupedCommand(s32 node_id, s16 buffer_count, s16 input_index,

/**

* Generate a device sink command, adding it to the command list.

*

*/

void GenerateDeviceSinkCommand(s32 node_id, s16 buffer_offset, SinkInfoBase& sink_info,

u32 session_id, std::span<s32> samples_buffer);

/**

* Generate an I3DL2 reverb effect command.

*

*/

void GenerateI3dl2ReverbEffectCommand(s16 buffer_offset, EffectInfoBase& effect_info,

s32 node_id);

/**

* Generate an aux effect command.

*

*/

void GenerateAuxCommand(s16 buffer_offset, EffectInfoBase& effect_info, s32 node_id);

/**

* Generate a biquad filter effect command.

*

*/

void GenerateBiquadFilterEffectCommand(s16 buffer_offset, EffectInfoBase& effect_info,

s32 node_id);

/**

* Generate a light limiter effect command.

*

*/

void GenerateLightLimiterEffectCommand(s16 buffer_offset, EffectInfoBase& effect_info,

s32 node_id, u32 effect_index);

* Generate a capture effect command.

* Writes a mix buffer back to game memory.

*

*/

void GenerateCaptureCommand(s16 buffer_offset, EffectInfoBase& effect_info, s32 node_id);

/**

* Generate a compressor effect command.

*

*/

/**

* Generate all effect commands for a mix.

* Generate a performance command.

* Used to report performance metrics of the AudioRenderer back to the game.

*

*/

void GeneratePerformanceCommand(s32 node_id, PerformanceState state,

const PerformanceEntryAddresses& entry_addresses);

namespace AudioCore::AudioRenderer {

CompressorInfo::State& state) {

const auto ratio{1.0f / params.compressor_ratio};

auto makeup_gain{0.0f};

state.unk_20 = c;

}

CompressorInfo::State& state) {

state.unk_00 = 0;

state.unk_04 = 1.0f;

SetCompressorEffectParameter(params, state);

}

CompressorInfo::State& state, bool enabled,

std::vector<std::span<const s32>> input_buffers,

std::vector<std::span<s32>> output_buffers, u32 sample_count) {

} else {

for (s16 channel = 0; channel < params.channel_count; channel++) {

if (params.inputs[channel] != params.outputs[channel]) {

output_buffers[channel].size_bytes());

}

}

#include "common/logging/log.h"

namespace AudioCore::AudioRenderer {

template <size_t Q>

s32 ApplyMixRamp(std::span<s32> output, std::span<const s32> input, const f32 volume_,

const f32 ramp_, const u32 sample_count) {

return sample.to_int();

}

void MixRampCommand::Dump(const ADSP::CommandListProcessor& processor, std::string& string) {

const auto ramp{(volume - prev_volume) / static_cast<f32>(processor.sample_count)};

* @tparam Q - Number of bits for fixed point operations.

* @param output - Output mix buffer.

* @param input - Input mix buffer.

* @param sample_count - Number of samples to process.

* @return The final gained input sample, used for depopping.

*/

template <size_t Q>

} // namespace AudioCore::AudioRenderer

std::array<s16, MaxMixBuffers> inputs;

/// Output mix buffer indexes for each mix buffer

std::array<s16, MaxMixBuffers> outputs;

std::array<f32, MaxMixBuffers> prev_volumes;

std::array<f32, MaxMixBuffers> volumes;

/// Pointer to the previous sample buffer, used for depop

CpuAddr previous_samples;

out_buffer.tag = reinterpret_cast<u64>(samples.data());

stream->AppendBuffer(out_buffer, samples);

}

bool DeviceSinkCommand::Verify(const ADSP::CommandListProcessor& processor) {

public:

/**

* Initialize the effect context

*/

std::span<EffectResultState> result_states_cpu_,

/**

* Get the EffectInfo for a given index

* Update the info with new parameters, version 1.

*

* @param error_info - Used to write call result code.

* @param pool_mapper - Pool for mapping buffers.

*/

virtual void Update(BehaviorInfo::ErrorInfo& error_info,

* Update the info with new parameters, version 2.

*

* @param error_info - Used to write call result code.

* @param pool_mapper - Pool for mapping buffers.

*/

virtual void Update(BehaviorInfo::ErrorInfo& error_info,

/**

* Setup a new AddressInfo.

*

*/

void Setup(CpuAddr cpu_address_, u64 size_) {

cpu_address = cpu_address_;

* Assign this region to a memory pool.

*

* @param memory_pool_ - Memory pool to assign.

*/

void SetPool(MemoryPoolInfo* memory_pool_) {

memory_pool = memory_pool_;

/**

* Initialize the node states.

*

* @param node_buffer_size - The size of the workbuffer. Unused.

* @param count - The number of nodes in the graph.

*/

/**

* Sort the graph. Only calls DepthFirstSearch.

* Calculate the required size for the performance workbuffer.

*

* @param behavior - Check which version is supported.

* @return Required workbuffer size.

*/

static u64 GetRequiredBufferSizeForPerformanceMetricsPerFrame(

* @param workbuffer - Workbuffer to use for performance frames.

* @param workbuffer_size - Size of the workbuffer.

* @param params - Input parameters.

* @param memory_pool - Used to translate the workbuffer address for the DSP.

*/

virtual void Initialize(std::span<u8> workbuffer, u64 workbuffer_size,

* workbuffer, to be written by the AudioRenderer.

*

* @param addresses - Filled with pointers to the new detail, which should be passed

* @param entry_type - The type of this detail. See PerformanceEntryType

* @param node_id - Node id for this detail.

* @return True if a new detail was created and the offsets are valid, otherwise false.

MP_RGB(60, 19, 97));

namespace AudioCore::AudioRenderer {

SystemManager::SystemManager(Core::System& core_)

: core{core_}, adsp{core.AudioCore().GetADSP()}, mailbox{adsp.GetRenderMailbox()},

thread_event{Core::Timing::CreateEvent(

"AudioRendererSystemManager", [this](std::uintptr_t, s64 time, std::chrono::nanoseconds) {

return ThreadFunc2(time);

SystemManager::~SystemManager() {

Stop();

if (adsp.Start()) {

active = true;

thread = std::jthread([this](std::stop_token stop_token) { ThreadFunc(); });

}

}

}

std::optional<std::chrono::nanoseconds> SystemManager::ThreadFunc2(s64 time) {

update.store(true);

update.notify_all();

}

} // namespace AudioCore::AudioRenderer

*/

std::optional<std::chrono::nanoseconds> ThreadFunc2(s64 time);

enum class StreamState {

Filling,

Steady,

std::shared_ptr<Core::Timing::EventType> thread_event;

/// Atomic for main thread to wait on

std::atomic<bool> update{};

};

} // namespace AudioCore::AudioRenderer

/**

* Free the given upsampler.

*

*/

void Free(UpsamplerInfo* info);

/**

* Does this voice ned an update?

*

* @return True if this voice needs an update, otherwise false.

*/

bool ShouldUpdateParameters(const InParameter& params) const;

* Update the parameters of this voice.

*

* @param error_info - Output error code.

* @param pool_mapper - Used to map buffers.

*/

void UpdateParameters(BehaviorInfo::ErrorInfo& error_info, const InParameter& params,

const PoolMapper& pool_mapper, const BehaviorInfo& behavior);

/**

* Update all wavebuffers.

*

* @param voice_states - The voice states for each channel in this voice to be updated.

*/

void UpdateWaveBuffers(std::span<std::array<BehaviorInfo::ErrorInfo, 2>> error_infos,

u32 error_count, const InParameter& params,

/**

* Update a wavebuffer.

*

* @param wave_buffer - The wavebuffer to be updated.

* @param wave_buffer_internal - Input parametters to be used for the update.

* @param sample_format - Sample format of the wavebuffer.

* @param valid - Is this wavebuffer valid?

* @param pool_mapper - Used to map the wavebuffers.

*/

void UpdateWaveBuffer(std::span<BehaviorInfo::ErrorInfo> error_info, WaveBuffer& wave_buffer,

const WaveBufferInternal& wave_buffer_internal,

/**

* Check if this voice has any mixing connections.

*

*/

bool HasAnyConnection() const;

/**

* Update this voice on command generation.

*

* @return True if this voice should be generated, otherwise false.

*/

bool UpdateForCommandGeneration(VoiceContext& voice_context);

// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project

// SPDX-License-Identifier: GPL-2.0-or-later

#include <span>

#include "audio_core/sink/cubeb_sink.h"

#include "audio_core/sink/sink_stream.h"

#include "common/logging/log.h"

#include "core/core.h"

#ifdef _WIN32

* @param system_ - Core system.

* @param event - Event used only for audio renderer, signalled on buffer consume.

*/

cubeb_devid output_device, cubeb_devid input_device, const std::string& name_,

#ifdef _WIN32

CoInitializeEx(nullptr, COINIT_MULTITHREADED);

#endif

minimum_latency = std::max(minimum_latency, 256u);

auto init_error{0};

if (type == StreamType::In) {

~CubebSinkStream() override {

LOG_DEBUG(Service_Audio, "Destructing cubeb stream {}", name);

if (!ctx) {

return;

}

* @param resume - Set to true if this is resuming the stream a previously-active stream.

* Default false.

*/

return;

}

}

}

* Stop the sink stream.

*/

void Stop() override {

return;

}

if (cubeb_stream_stop(stream_backend) != CUBEB_OK) {

LOG_CRITICAL(Audio_Sink, "Error stopping cubeb stream");

}

}

private:

/**

* Main callback from Cubeb. Either expects samples from us (audio render/audio out), or will

* provide samples to be copied (audio in).

*

const std::size_t num_channels = impl->GetDeviceChannels();

const std::size_t frame_size = num_channels;

const std::size_t num_frames{static_cast<size_t>(num_frames_)};

if (impl->type == StreamType::In) {

std::span<const s16> input_buffer{reinterpret_cast<const s16*>(in_buff),

num_frames * frame_size};

} else {

std::span<s16> output_buffer{reinterpret_cast<s16*>(out_buff), num_frames * frame_size};

}

return num_frames_;

* @param user_data - Custom data pointer passed along, points to a CubebSinkStream.

* @param state - New state of the device.

*/

/// Main Cubeb context

cubeb* ctx{};

/// Cubeb stream backend

cubeb_stream* stream_backend{};

};

CubebSink::CubebSink(std::string_view target_device_name) {

#endif

}

SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<CubebSinkStream>(

ctx, device_channels, system_channels, output_device, input_device, name, type, system));

return stream.get();

}

for (size_t i = 0; i < sink_streams.size(); i++) {

if (sink_streams[i].get() == stream) {

sink_streams[i].reset();

sink_streams.clear();

}

f32 CubebSink::GetDeviceVolume() const {

if (sink_streams.empty()) {

return 1.0f;

return sink_streams[0]->GetDeviceVolume();

}

for (auto& stream : sink_streams) {

stream->SetDeviceVolume(volume);

}

}

for (auto& stream : sink_streams) {

stream->SetSystemVolume(volume);

}

}

std::vector<std::string> device_list;

cubeb* ctx;

* May differ from the device's channel count.

* @param name - Name of this stream.

* @param type - Type of this stream, render/in/out.

* @return A pointer to the created SinkStream

*/

SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,

*

* @param stream - The stream to close.

*/

/**

* Close all streams.

void CloseStreams() override;

/**

* Get the device volume. Set from calls to the IAudioDevice service.

*

* @return Volume of the device.

};

/**

*

* @param capture - Return input (capture) devices if true, otherwise output devices.

*/

#pragma once

#include "audio_core/sink/sink.h"

#include "audio_core/sink/sink_stream.h"

namespace AudioCore::Sink {

/**

* A no-op sink for when no audio out is wanted.

*/

explicit NullSink(std::string_view) {}

~NullSink() override = default;

}

void CloseStreams() override {}

f32 GetDeviceVolume() const override {

return 1.0f;

}

void SetSystemVolume(f32 volume) override {}

private:

};

} // namespace AudioCore::Sink

// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project

// SPDX-License-Identifier: GPL-2.0-or-later

#include "audio_core/sink/sdl2_sink.h"

#include "audio_core/sink/sink_stream.h"

#include "common/logging/log.h"

#include "core/core.h"

// Ignore -Wimplicit-fallthrough due to https://github.com/libsdl-org/SDL/issues/4307

* @param system_ - Core system.

* @param event - Event used only for audio renderer, signalled on buffer consume.

*/

system_channels = system_channels_;

device_channels = device_channels_;

spec.callback = &SDLSinkStream::DataCallback;

spec.userdata = this;

std::string device_name{output_device};

bool capture{false};

if (type == StreamType::In) {

return;

}

}

/**

* Destroy the sink stream.

*/

~SDLSinkStream() override {

}

/**

* Finalize the sink stream.

*/

void Finalize() override {

if (device == 0) {

return;

}

SDL_CloseAudioDevice(device);

}

* @param resume - Set to true if this is resuming the stream a previously-active stream.

* Default false.

*/

return;

}

}

/**

* Stop the sink stream.

*/

return;

}

paused = true;

}

private:

/**

* Main callback from SDL. Either expects samples from us (audio render/audio out), or will

* provide samples to be copied (audio in).

*

const std::size_t num_channels = impl->GetDeviceChannels();

const std::size_t frame_size = num_channels;

const std::size_t num_frames{len / num_channels / sizeof(s16)};

if (impl->type == StreamType::In) {

} else {

std::span<s16> output_buffer{reinterpret_cast<s16*>(stream), num_frames * frame_size};

}

}

/// SDL device id of the opened input/output device

SDL_AudioDeviceID device{};

};

SDLSink::SDLSink(std::string_view target_device_name) {

SDLSink::~SDLSink() = default;

SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<SDLSinkStream>(

device_channels, system_channels, output_device, input_device, type, system));

return stream.get();

}

for (size_t i = 0; i < sink_streams.size(); i++) {

if (sink_streams[i].get() == stream) {

sink_streams[i].reset();

sink_streams.clear();

}

f32 SDLSink::GetDeviceVolume() const {

if (sink_streams.empty()) {

return 1.0f;

return sink_streams[0]->GetDeviceVolume();

}

for (auto& stream : sink_streams) {

stream->SetDeviceVolume(volume);

}

}

for (auto& stream : sink_streams) {

stream->SetSystemVolume(volume);

}

}

std::vector<std::string> device_list;

if (!SDL_WasInit(SDL_INIT_AUDIO)) {

* May differ from the device's channel count.

* @param name - Name of this stream.

* @param type - Type of this stream, render/in/out.

* @return A pointer to the created SinkStream

*/

SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,

*

* @param stream - The stream to close.

*/

/**

* Close all streams.

void CloseStreams() override;

/**

* Get the device volume. Set from calls to the IAudioDevice service.

*

* @return Volume of the device.

};

/**

*

* @param capture - Return input (capture) devices if true, otherwise output devices.

*/

*

* @param stream - The stream to close.

*/

/**

* Close all streams.

virtual void CloseStreams() = 0;

/**

* Create a new sink stream, kept within this sink, with a pointer returned for use.

* Do not free the returned pointer. When done with the stream, call CloseStream on the sink.

*

* May differ from the device's channel count.

* @param name - Name of this stream.

* @param type - Type of this stream, render/in/out.

* @return A pointer to the created SinkStream

*/

virtual SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,

#include <memory>

#include <string>

#include <vector>

#include "audio_core/sink/sink_details.h"

#ifdef HAVE_CUBEB

#include "audio_core/sink/cubeb_sink.h"

#ifdef HAVE_SDL2

#include "audio_core/sink/sdl2_sink.h"

#endif

#include "common/logging/log.h"

namespace AudioCore::Sink {

if (sink_id == "auto" || iter == std::end(sink_details)) {

if (sink_id != "auto") {

}

// Auto-select.

// sink_details is ordered in terms of desirability, with the best choice at the front.

#pragma once

#include <atomic>

#include <memory>

#include <vector>

#include "audio_core/common/common.h"

#include "common/common_types.h"

namespace AudioCore::Sink {

* You should regularly call IsBufferConsumed with the unique SinkBuffer tag to check if the buffer

* has been consumed.

*

*

* If the buffers appear to be stuck, you can stop and re-open an IAudioIn/IAudioOut service (this

* is what games do), or call ClearQueue to flush all of the buffers without a full restart.

*/

class SinkStream {

public:

/**

* Finalize the sink stream.

*/

/**

* Start the sink stream.

* @param resume - Set to true if this is resuming the stream a previously-active stream.

* Default false.

*/

/**

* Stop the sink stream.

*/

/**

* Check if the stream is paused.

*

* @return True if paused, otherwise false.

*/

return paused;

}

}

/**

* Get the system volume.

*

* @return The current system volume.

return queued_buffers.load();

}

protected:

/// Set by the audio render/in/out system which uses this stream

u32 system_channels{2};

/// Channels supported by hardware

u32 device_channels{2};

/// Is this stream currently paused?

std::atomic<bool> paused{true};

};

using SinkStreamPtr = std::unique_ptr<SinkStream>;

x64/xbyak_abi.h

x64/xbyak_util.h

)

endif()

if (MSVC)

create_target_directory_groups(common)

target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)

if (TARGET zstd::zstd)

target_link_libraries(common PRIVATE zstd::zstd)

else()

float offset{};

// Invert direction of the sensor data

bool inverted{};

};

// Single analog sensor data

struct ButtonStatus {

Common::UUID uuid{};

bool value{};

bool inverted{};

bool toggle{};

bool locked{};

};

values.shader_backend.SetGlobal(true);

values.use_asynchronous_shaders.SetGlobal(true);

values.use_fast_gpu_time.SetGlobal(true);

values.bg_red.SetGlobal(true);

values.bg_green.SetGlobal(true);

values.bg_blue.SetGlobal(true);

ShaderBackend::SPIRV, "shader_backend"};

SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};

SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};

SwitchableSetting<u8> bg_red{0, "bg_red"};

SwitchableSetting<u8> bg_green{0, "bg_green"};

core_timing.SyncPause(false);

is_paused = false;

return status;

}

std::unique_lock<std::mutex> lk(suspend_guard);

status = SystemResultStatus::Success;

core_timing.SyncPause(true);

kernel.Suspend(true);

is_paused = true;

if (timer_thread) {

timer_thread->join();

}

ClearPendingEvents();

timer_thread.reset();

has_started = false;

if (!is_paused) {

pause_end_time = GetGlobalTimeNs().count();

}

}

void CoreTiming::SyncPause(bool is_paused) {

if (!is_paused) {

pause_end_time = GetGlobalTimeNs().count();

}

}

bool CoreTiming::IsRunning() const {

}

}

std::optional<s64> CoreTiming::Advance() {

std::scoped_lock lock{advance_lock, basic_lock};

global_timer = GetGlobalTimeNs().count();

/// A callback that may be scheduled for a particular core timing event.

using TimedCallback = std::function<std::optional<std::chrono::nanoseconds>(

std::uintptr_t user_data, s64 time, std::chrono::nanoseconds ns_late)>;

/// Contains the characteristics of a particular event.

struct EventType {

/// Checks for events manually and returns time in nanoseconds for next event, threadsafe.

std::optional<s64> Advance();

private:

struct Event;

/// Cycle timing

u64 ticks{};

s64 downcount{};

};

/// Creates a core timing event with the given name and callback.

return;

}

switch (index) {

case Settings::NativeButton::A:

controller.npad_button_state.a.Assign(current_status.value);

return;

}

const auto& trigger = controller.trigger_values[index];

switch (index) {

Common::Input::ButtonStatus status{};

switch (callback.type) {

case Common::Input::InputType::Analog:

case Common::Input::InputType::Trigger:

status.value = TransformToTrigger(callback).pressed.value;

break;

BitField<0, 9, ErrorModule> module;

BitField<9, 13, u32> description;

constexpr explicit Result(u32 raw_) : raw(raw_) {}

constexpr Result(ErrorModule module_, u32 description_)

return !IsSuccess();

}

};

[[nodiscard]] constexpr bool operator==(const Result& a, const Result& b) {

return a.raw == b.raw;

const auto write_count =

static_cast<u32>(ctx.GetWriteBufferSize() / sizeof(AudioDevice::AudioDeviceName));

std::vector<AudioDevice::AudioDeviceName> device_names{};

if (write_count > 0) {

LOG_DEBUG(Service_Audio, "called. \nName=DeviceOut");

} else {

LOG_DEBUG(Service_Audio, "called. Empty buffer passed in.");

std::vector<AudioDevice::AudioDeviceName> out_names{};

std::string out{};

for (u32 i = 0; i < out_count; i++) {

std::vector<AudioDevice::AudioDeviceName> out_names{};

std::string out{};

for (u32 i = 0; i < out_count; i++) {

// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project

// SPDX-License-Identifier: GPL-2.0-or-later

#include "common/assert.h"

#include "common/logging/log.h"

#include "core/core.h"

return NvResult::NotImplemented;

}

void nvhost_nvdec::OnClose(DeviceFD fd) {

LOG_INFO(Service_NVDRV, "NVDEC video stream ended");

if (iter != fd_to_id.end()) {

system.GPU().ClearCdmaInstance(iter->second);

}

}

} // namespace Service::Nvidia::Devices

target_link_libraries(yuzu-room PRIVATE web_service)

endif()

if (MSVC)

target_link_libraries(yuzu-room PRIVATE getopt)

endif()

void EnableMotion() {

if (sdl_controller) {

SDL_GameController* controller = sdl_controller.get();

SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_ACCEL, SDL_TRUE);

}

SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);

}

}

}

auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick, sdl_gamecontroller);

PreSetController(joystick->GetPadIdentifier());

SetBattery(joystick->GetPadIdentifier(), joystick->GetBatteryLevel());

joystick_map[guid].emplace_back(std::move(joystick));

return;

}

if (joystick_it != joystick_guid_list.end()) {

(*joystick_it)->SetSDLJoystick(sdl_joystick, sdl_gamecontroller);

return;

}

auto joystick = std::make_shared<SDLJoystick>(guid, port, sdl_joystick, sdl_gamecontroller);

PreSetController(joystick->GetPadIdentifier());

SetBattery(joystick->GetPadIdentifier(), joystick->GetBatteryLevel());

joystick_guid_list.emplace_back(std::move(joystick));

}

.threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f),

.offset = std::clamp(params.Get("offset", 0.0f), -1.0f, 1.0f),

.inverted = params.Get("invert", "+") == "-",

};

input_engine->PreSetController(identifier);

input_engine->PreSetAxis(identifier, axis);

inst->SetFlags(flags);

break;

case IR::Opcode::ImageSampleImplicitLod:

}

break;

case IR::Opcode::ImageFetch:

#include "common/common_funcs.h"

#include "common/common_types.h"

#include "common/div_ceil.h"

#include "core/memory.h"

namespace VideoCommon {

NotifyRasterizer<false>(word_index, untracked_words[word_index], cached_bits);

untracked_words[word_index] |= cached_bits;

cpu_words[word_index] |= cached_bits;

}

}

using VideoCommon::SerializePipeline;

using Context = ShaderContext::Context;

template <typename Container>

auto MakeSpan(Container& container) {

using VideoCommon::GenericEnvironment;

using VideoCommon::GraphicsEnvironment;

template <typename Container>

auto MakeSpan(Container& container) {

return Shader::TextureType::Color1D;

case Tegra::Texture::TextureType::Texture2D:

case Tegra::Texture::TextureType::Texture2DNoMipmap:

case Tegra::Texture::TextureType::Texture3D:

return Shader::TextureType::Color3D;

case Tegra::Texture::TextureType::TextureCubemap:

ReadGlobalSetting(Settings::values.shader_backend);

ReadGlobalSetting(Settings::values.use_asynchronous_shaders);

ReadGlobalSetting(Settings::values.use_fast_gpu_time);

ReadGlobalSetting(Settings::values.bg_red);

ReadGlobalSetting(Settings::values.bg_green);

ReadGlobalSetting(Settings::values.bg_blue);

Settings::values.shader_backend.UsingGlobal());

WriteGlobalSetting(Settings::values.use_asynchronous_shaders);

WriteGlobalSetting(Settings::values.use_fast_gpu_time);

WriteGlobalSetting(Settings::values.bg_red);

WriteGlobalSetting(Settings::values.bg_green);

WriteGlobalSetting(Settings::values.bg_blue);

ui->use_vsync->setChecked(Settings::values.use_vsync.GetValue());

ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());

ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());

if (Settings::IsConfiguringGlobal()) {

ui->gpu_accuracy->setCurrentIndex(

use_asynchronous_shaders);

ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_fast_gpu_time,

ui->use_fast_gpu_time, use_fast_gpu_time);

}

void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {

ui->use_asynchronous_shaders->setEnabled(

Settings::values.use_asynchronous_shaders.UsingGlobal());

ui->use_fast_gpu_time->setEnabled(Settings::values.use_fast_gpu_time.UsingGlobal());

ui->anisotropic_filtering_combobox->setEnabled(

Settings::values.max_anisotropy.UsingGlobal());

use_asynchronous_shaders);

ConfigurationShared::SetColoredTristate(ui->use_fast_gpu_time,

Settings::values.use_fast_gpu_time, use_fast_gpu_time);

ConfigurationShared::SetColoredComboBox(

ui->gpu_accuracy, ui->label_gpu_accuracy,

static_cast<int>(Settings::values.gpu_accuracy.GetValue(true)));

ConfigurationShared::CheckState use_vsync;

ConfigurationShared::CheckState use_asynchronous_shaders;

ConfigurationShared::CheckState use_fast_gpu_time;

const Core::System& system;

};

</widget>

</item>

<item>

<widget class="QWidget" name="af_layout" native="true">

<layout class="QHBoxLayout" name="horizontalLayout_1">

<property name="leftMargin">

const QString toggle = QString::fromStdString(param.Get("toggle", false) ? "~" : "");

const QString inverted = QString::fromStdString(param.Get("inverted", false) ? "!" : "");

const auto common_button_name = input_subsystem->GetButtonName(param);

// Retrieve the names from Qt

}

if (param.Has("axis")) {

const QString axis = QString::fromStdString(param.Get("axis", ""));

}

if (param.Has("axis_x") && param.Has("axis_y") && param.Has("axis_z")) {

const QString axis_x = QString::fromStdString(param.Get("axis_x", ""));

button_map[button_id]->setText(tr("[not set]"));

});

if (param.Has("code") || param.Has("button") || param.Has("hat")) {

context_menu.addAction(tr("Invert button"), [&] {

const bool invert_value = !param.Get("inverted", false);

param.Set("inverted", invert_value);

button_map[button_id]->setText(ButtonToText(param));

emulated_controller->SetButtonParam(button_id, param);

});

}

if (param.Has("axis")) {

context_menu.addAction(tr("Invert axis"), [&] {

}

emulated_controller->SetButtonParam(button_id, param);

});

}

context_menu.exec(button_map[button_id]->mapToGlobal(menu_location));

});

ui->controllerFrame->BeginMappingAnalog(button_id);

}

poll_timer->start(25); // Check for new inputs every 25ms

}

<property name="text">

<string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Reads controller input from scripts in the same format as TAS-nx scripts.&lt;br/&gt;For a more detailed explanation, please consult the &lt;a href=&quot;https://yuzu-emu.org/help/feature/tas/&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#039be5;&quot;&gt;help page&lt;/span&gt;&lt;/a&gt; on the yuzu website.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>

</property>

</widget>

</item>

<item row="1" column="0" colspan="4">

ReadSetting("Renderer", Settings::values.nvdec_emulation);

ReadSetting("Renderer", Settings::values.accelerate_astc);

ReadSetting("Renderer", Settings::values.use_fast_gpu_time);

ReadSetting("Renderer", Settings::values.bg_red);

ReadSetting("Renderer", Settings::values.bg_green);

# 0: Off, 1 (default): On

use_fast_gpu_time =

# Whether to use garbage collection or not for GPU caches.

# 0 (default): Off, 1: On

use_caches_gc =