RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 20:17:44 +00:00
Code Issues Activity Actions

Piano: Move to LibDSP's Classic synthesizer

Browse source 
Almost all synthesizer code in Piano is removed in favor of the LibDSP
reimplementation.

This causes some issues that mainly have to do with the way Piano
currently handles talking to LibDSP. Additionally, the sampler is gone
for now and will be reintroduced with future work.
This commit is contained in:
kleines Filmröllchen 2021-09-28 18:01:39 +02:00 • committed by Andreas Kling
parent 3ca059da2d
commit b14a64b3c8
14 changed files with 128 additions and 464 deletions
Download patch file Download diff file Expand all files Collapse all files

42
Userland/Applications/Piano/Track.h
View file

@ -10,10 +10,14 @@
#include "Music.h"
#include <AK/Noncopyable.h>
#include <AK/NonnullRefPtr.h>
#include <AK/SinglyLinkedList.h>
#include <LibAudio/Buffer.h>
#include <LibDSP/Effects.h>
#include <LibDSP/Music.h>
#include <LibDSP/Synthesizers.h>
using LibDSP::RollNote;
using RollIter = AK::SinglyLinkedListIterator<SinglyLinkedList<RollNote>, RollNote>;
class Track {
@ -26,63 +30,33 @@ public:
const Vector<Audio::Sample>& recorded_sample() const { return m_recorded_sample; }
const SinglyLinkedList<RollNote>& roll_notes(int note) const { return m_roll_notes[note]; }
int wave() const { return m_wave; }
int volume() const { return m_volume; }
int attack() const { return m_attack; }
int decay() const { return m_decay; }
int sustain() const { return m_sustain; }
int release() const { return m_release; }
NonnullRefPtr<LibDSP::Synthesizers::Classic> synth() { return m_synth; }
NonnullRefPtr<LibDSP::Effects::Delay> delay() { return m_delay; }
void fill_sample(Sample& sample);
void reset();
String set_recorded_sample(StringView path);
void set_note(int note, Switch);
void set_roll_note(int note, u32 on_sample, u32 off_sample);
void set_wave(int wave);
void set_wave(Direction);
void set_keyboard_note(int note, Switch state);
void set_volume(int volume);
void set_attack(int attack);
void set_decay(int decay);
void set_sustain(int sustain);
void set_release(int release);
private:
Audio::Sample sine(size_t note);
Audio::Sample saw(size_t note);
Audio::Sample square(size_t note);
Audio::Sample triangle(size_t note);
Audio::Sample noise(size_t note);
Audio::Sample recorded_sample(size_t note);
void sync_roll(int note);
void set_sustain_impl(int sustain);
Vector<Audio::Sample> m_recorded_sample;
u8 m_note_on[note_count] { 0 };
double m_power[note_count] { 0 };
double m_pos[note_count]; // Initialized lazily.
// Synths may use this to keep track of the last wave position
double m_last_w[note_count] { 0 };
Envelope m_envelope[note_count] { Done };
int m_wave { first_wave };
int m_volume;
int m_attack;
double m_attack_step;
int m_decay;
double m_decay_step;
int m_sustain;
double m_sustain_level;
int m_release;
double m_release_step[note_count];
const u32& m_time;
NonnullRefPtr<LibDSP::Transport> m_temporary_transport;
NonnullRefPtr<LibDSP::Effects::Delay> m_delay;
NonnullRefPtr<LibDSP::Synthesizers::Classic> m_synth;
SinglyLinkedList<RollNote> m_roll_notes[note_count];
RollIter m_roll_iterators[note_count];
Array<Optional<RollNote>, note_count> m_keyboard_notes;
};