6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2025-08-12 09:25:19 +00:00
Code Issues Projects Releases Wiki Activity

Endeavours to fix attenuation and add FM synthesis.

Browse Source 
I now definitely think my frequency counting is wrong.
This commit is contained in:
Thomas Harte
2020-04-14 18:32:06 -04:00
parent 09d1aed3a5
commit aa45142728
2 changed files with 18 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Components/OPL2/OPL2.cpp
View File

@@ -193,6 +193,7 @@ void OPLL::get_samples(std::size_t number_of_samples, std::int16_t *target) {
} }
void OPLL::set_sample_volume_range(std::int16_t range) { void OPLL::set_sample_volume_range(std::int16_t range) {
total_volume_ = range;
} }
uint8_t OPLL::read(uint16_t address) { uint8_t OPLL::read(uint16_t address) {
@@ -402,7 +403,7 @@ void Operator::update(OperatorState &state, bool key_on, int channel_frequency,
}; };
// Update the raw phase. // Update the raw phase.
const int octave_divider = 64 << channel_octave; const int octave_divider = 128 << channel_octave;
state.divider_ %= octave_divider; state.divider_ %= octave_divider;
state.divider_ += multipliers[frequency_multiple] * channel_frequency; state.divider_ += multipliers[frequency_multiple] * channel_frequency;
state.raw_phase_ += state.divider_ / octave_divider; state.raw_phase_ += state.divider_ / octave_divider;
@@ -509,11 +510,11 @@ void Operator::update(OperatorState &state, bool key_on, int channel_frequency,
state.time_in_phase_ = 0; state.time_in_phase_ = 0;
} }
// TODO: probably there's no multiply here? // Combine the ADSR attenuation and overall channel attenuation, clamping to the permitted range.
if(overrides) { if(overrides) {
state.attenuation = (state.adsr_attenuation_ * overrides->attenuation) >> 4; state.attenuation = state.adsr_attenuation_ + (overrides->attenuation << 5);
} else { } else {
state.attenuation = (state.adsr_attenuation_ * attenuation_) >> 6; state.attenuation = state.adsr_attenuation_ + (attenuation_ << 3);
} }
} }

21
Components/OPL2/OPL2.hpp
View File

@@ -13,6 +13,7 @@
#include "../../Concurrency/AsyncTaskQueue.hpp" #include "../../Concurrency/AsyncTaskQueue.hpp"
#include "../../Numeric/LFSR.hpp" #include "../../Numeric/LFSR.hpp"
#include <atomic>
#include <cmath> #include <cmath>
namespace Yamaha { namespace Yamaha {
@@ -25,8 +26,8 @@ namespace OPL {
*/ */
struct OperatorState { struct OperatorState {
public: public:
int phase = 0; // Will be in the range [0, 1023], mapping into a 1024-unit sine curve. int phase = 0; // Will be in the range [0, 1023], mapping into a 1024-unit sine curve.
int attenuation = 511; int attenuation = 255; // Will be in the range [0, 1023].
private: private:
int divider_ = 0; int divider_ = 0;
@@ -198,14 +199,16 @@ class Channel {
/// This should be called at a rate of around 49,716 Hz; it returns the current output level /// This should be called at a rate of around 49,716 Hz; it returns the current output level
/// level for this channel. /// level for this channel.
int update(Operator *modulator, Operator *carrier, OperatorOverrides *modulator_overrides = nullptr, OperatorOverrides *carrier_overrides = nullptr) { int update(Operator *modulator, Operator *carrier, OperatorOverrides *modulator_overrides = nullptr, OperatorOverrides *carrier_overrides = nullptr) {
// modulator->update(modulator_state_, key_on, frequency << frequency_shift, octave, modulator_overrides); modulator->update(modulator_state_, key_on, frequency << frequency_shift, octave, modulator_overrides);
carrier->update(carrier_state_, key_on, frequency << frequency_shift, octave, carrier_overrides); carrier->update(carrier_state_, key_on, frequency << frequency_shift, octave, carrier_overrides);
// TODO: almost everything else. This is a quick test. // TODO: almost everything else. This is a quick test.
// Specifically: use lookup tables, apply attenuation properly. // Specifically: use lookup tables.
if(carrier_state_.attenuation == 511) return 0; const float carrier_volume = logf(float(carrier_state_.attenuation + 1)) / logf(1023.0);
const float volume = 1.0f - float(carrier_state_.attenuation) / 511.0f; const float modulator_volume = logf(float(modulator_state_.attenuation + 1)) / logf(1023.0);
return int(volume * sin(float(carrier_state_.phase) / 1024.0) * 20000.0);
const float modulator_output = modulator_volume * sinf(float(modulator_state_.phase) / 1024.0f);
return int(carrier_volume * sinf(modulator_output + (float(carrier_state_.phase) / 1024.0f)) * 20000.0f);
} }
/// @returns @c true if this channel is currently producing any audio; @c false otherwise; /// @returns @c true if this channel is currently producing any audio; @c false otherwise;
@@ -328,7 +331,7 @@ struct OPLL: public OPLBase<OPLL> {
}; };
void update_all_chanels() { void update_all_chanels() {
for(int c = 0; c < 6; ++ c) { // Don't do anything with channels that might be percussion for now. for(int c = 0; c < 6; ++ c) { // Don't do anything with channels that might be percussion for now.
channels_[c].level = channels_[c].update(); channels_[c].level = (channels_[c].update() * total_volume_) >> 14;
} }
} }
Channel channels_[9]; Channel channels_[9];
@@ -340,6 +343,8 @@ struct OPLL: public OPLBase<OPLL> {
const int audio_divider_ = 1; const int audio_divider_ = 1;
int audio_offset_ = 0; int audio_offset_ = 0;
std::atomic<int> total_volume_;
}; };
} }