Merge branch 'master' into shader-decomp

include/audio/aac.hpp

@@ -54,6 +54,15 @@ namespace Audio::AAC {
 		u32_le sampleCount;
 	};
 
+	struct DecodeRequest {
+		u32_le address;        // Address of input AAC stream
+		u32_le size;           // Size of input AAC stream
+		u32_le destAddrLeft;   // Output address for left channel samples
+		u32_le destAddrRight;  // Output address for right channel samples
+		u32_le unknown1;
+		u32_le unknown2;
+	};
+
 	struct Message {
 		u16_le mode = Mode::None;  // Encode or decode AAC?
 		u16_le command = Command::Init;
@@ -62,7 +71,9 @@ namespace Audio::AAC {
 		// Info on the AAC request
 		union {
 			std::array<u8, 24> commandData{};
+
 			DecodeResponse decodeResponse;
+			DecodeRequest decodeRequest;
 		};
 	};
 

include/audio/aac_decoder.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#include <functional>
+
+#include "audio/aac.hpp"
+#include "helpers.hpp"
+
+struct AAC_DECODER_INSTANCE;
+
+namespace Audio::AAC {
+	class Decoder {
+		using DecoderHandle = AAC_DECODER_INSTANCE*;
+		using PaddrCallback = std::function<u8*(u32)>;
+
+		DecoderHandle decoderHandle = nullptr;
+
+		bool isInitialized() { return decoderHandle != nullptr; }
+		void initialize();
+
+	  public:
+		// Decode function. Takes in a reference to the AAC response & request, and a callback for paddr -> pointer conversions
+		void decode(AAC::Message& response, const AAC::Message& request, PaddrCallback paddrCallback);
+		~Decoder();
+	};
+}  // namespace Audio::AAC

include/audio/dsp_shared_mem.hpp

@@ -324,8 +324,8 @@ namespace Audio::HLE {
 			BitField<15, 1, u32> outputBufferCountDirty;
 			BitField<16, 1, u32> masterVolumeDirty;
 
-			BitField<24, 1, u32> auxReturnVolume0Dirty;
-			BitField<25, 1, u32> auxReturnVolume1Dirty;
+			BitField<24, 1, u32> auxVolume0Dirty;
+			BitField<25, 1, u32> auxVolume1Dirty;
 			BitField<26, 1, u32> outputFormatDirty;
 			BitField<27, 1, u32> clippingModeDirty;
 			BitField<28, 1, u32> headphonesConnectedDirty;
@@ -337,7 +337,7 @@ namespace Audio::HLE {
 		/// The DSP has three intermediate audio mixers. This controls the volume level (0.0-1.0) for
 		/// each at the final mixer.
 		float_le masterVolume;
-		std::array<float_le, 2> auxReturnVolume;
+		std::array<float_le, 2> auxVolumes;
 
 		u16_le outputBufferCount;
 		u16 pad1[2];
@@ -422,7 +422,7 @@ namespace Audio::HLE {
 
 	struct DspStatus {
 		u16_le unknown;
-		u16_le dropped_frames;
+		u16_le droppedFrames;
 		u16 pad0[0xE];
 	};
 	ASSERT_DSP_STRUCT(DspStatus, 32);

include/audio/hle_core.hpp

@@ -2,10 +2,12 @@
 #include <array>
 #include <cassert>
 #include <deque>
+#include <memory>
 #include <queue>
 #include <vector>
 
 #include "audio/aac.hpp"
+#include "audio/aac_decoder.hpp"
 #include "audio/dsp_core.hpp"
 #include "audio/dsp_shared_mem.hpp"
 #include "memory.hpp"
@@ -33,8 +35,8 @@ namespace Audio {
 			SampleFormat format;
 			SourceType sourceType;
 
-			bool fromQueue = false;        // Is this buffer from the buffer queue or an embedded buffer?
-			bool hasPlayedOnce = false;    // Has the buffer been played at least once before?
+			bool fromQueue = false;      // Is this buffer from the buffer queue or an embedded buffer?
+			bool hasPlayedOnce = false;  // Has the buffer been played at least once before?
 
 			bool operator<(const Buffer& other) const {
 				// Lower ID = Higher priority
@@ -93,8 +95,7 @@ namespace Audio {
 		DSPSource() { reset(); }
 	};
 
-	class HLE_DSP : public DSPCore {
-		// The audio frame types are public in case we want to use them for unit tests
+	class DSPMixer {
 	  public:
 		template <typename T, usize channelCount = 1>
 		using Sample = std::array<T, channelCount>;
@@ -111,6 +112,43 @@ namespace Audio {
 		template <typename T>
 		using QuadFrame = Frame<T, 4>;
 
+	  private:
+		using ChannelFormat = HLE::DspConfiguration::OutputFormat;
+		// The audio from each DSP voice is converted to quadraphonic and then fed into 3 intermediate mixing stages
+		// Two of these intermediate mixers (second and third) are used for effects, including custom effects done on the CPU
+		static constexpr usize mixerStageCount = 3;
+
+	  public:
+		ChannelFormat channelFormat = ChannelFormat::Stereo;
+		std::array<float, mixerStageCount> volumes;
+		std::array<bool, 2> enableAuxStages;
+
+		void reset() {
+			channelFormat = ChannelFormat::Stereo;
+
+			volumes.fill(0.0);
+			enableAuxStages.fill(false);
+		}
+	};
+
+	class HLE_DSP : public DSPCore {
+		// The audio frame types are public in case we want to use them for unit tests
+	  public:
+		template <typename T, usize channelCount = 1>
+		using Sample = DSPMixer::Sample<T, channelCount>;
+
+		template <typename T, usize channelCount>
+		using Frame = DSPMixer::Frame<T, channelCount>;
+
+		template <typename T>
+		using MonoFrame = DSPMixer::MonoFrame<T>;
+
+		template <typename T>
+		using StereoFrame = DSPMixer::StereoFrame<T>;
+
+		template <typename T>
+		using QuadFrame = DSPMixer::QuadFrame<T>;
+
 		using Source = Audio::DSPSource;
 		using SampleBuffer = Source::SampleBuffer;
 
@@ -129,6 +167,9 @@ namespace Audio {
 		std::array<Source, Audio::HLE::sourceCount> sources;  // DSP voices
 		Audio::HLE::DspMemory dspRam;
 
+		Audio::DSPMixer mixer;
+		std::unique_ptr<Audio::AAC::Decoder> aacDecoder;
+
 		void resetAudioPipe();
 		bool loaded = false;  // Have we loaded a component?
 
@@ -171,10 +212,13 @@ namespace Audio {
 
 		void handleAACRequest(const AAC::Message& request);
 		void updateSourceConfig(Source& source, HLE::SourceConfiguration::Configuration& config, s16_le* adpcmCoefficients);
+		void updateMixerConfig(HLE::SharedMemory& sharedMem);
 		void generateFrame(StereoFrame<s16>& frame);
 		void generateFrame(DSPSource& source);
 		void outputFrame();
-
+		// Perform the final mix, mixing the quadraphonic samples from all voices into the output audio frame
+		void performMix(Audio::HLE::SharedMemory& readRegion, Audio::HLE::SharedMemory& writeRegion);
+		
 		// Decode an entire buffer worth of audio
 		void decodeBuffer(DSPSource& source);
 

include/panda_qt/cheats_window.hpp

@@ -1,6 +1,13 @@
 #pragma once
 
 #include <QAction>
+#include <QCheckBox>
+#include <QDialog>
+#include <QLabel>
+#include <QLineEdit>
+#include <QListWidget>
+#include <QPushButton>
+#include <QTextEdit>
 #include <QWidget>
 #include <filesystem>
 #include <memory>
@@ -24,3 +31,60 @@ class CheatsWindow final : public QWidget {
 	std::filesystem::path cheatPath;
 	Emulator* emu;
 };
+
+struct CheatMetadata {
+	u32 handle = Cheats::badCheatHandle;
+	std::string name = "New cheat";
+	std::string code;
+	bool enabled = true;
+};
+
+class CheatEntryWidget : public QWidget {
+	Q_OBJECT
+
+  public:
+	CheatEntryWidget(Emulator* emu, CheatMetadata metadata, QListWidget* parent);
+
+	void Update() {
+		name->setText(metadata.name.c_str());
+		enabled->setChecked(metadata.enabled);
+		update();
+	}
+
+	void Remove() {
+		emu->getCheats().removeCheat(metadata.handle);
+		cheatList->takeItem(cheatList->row(listItem));
+		deleteLater();
+	}
+
+	const CheatMetadata& getMetadata() { return metadata; }
+	void setMetadata(const CheatMetadata& metadata) { this->metadata = metadata; }
+
+  private:
+	void checkboxChanged(int state);
+	void editClicked();
+
+	Emulator* emu;
+	CheatMetadata metadata;
+	u32 handle;
+	QLabel* name;
+	QCheckBox* enabled;
+	QListWidget* cheatList;
+	QListWidgetItem* listItem;
+};
+
+class CheatEditDialog : public QDialog {
+	Q_OBJECT
+
+  public:
+	CheatEditDialog(Emulator* emu, CheatEntryWidget& cheatEntry);
+
+	void accepted();
+	void rejected();
+
+  private:
+	Emulator* emu;
+	CheatEntryWidget& cheatEntry;
+	QTextEdit* codeEdit;
+	QLineEdit* nameEdit;
+};

include/panda_qt/main_window.hpp

@@ -140,7 +140,7 @@ class MainWindow : public QMainWindow {
 	MainWindow(QApplication* app, QWidget* parent = nullptr);
 	~MainWindow();
 
-	void closeEvent(QCloseEvent *event) override;
+	void closeEvent(QCloseEvent* event) override;
 	void keyPressEvent(QKeyEvent* event) override;
 	void keyReleaseEvent(QKeyEvent* event) override;
 	void mousePressEvent(QMouseEvent* event) override;