wirtz
/
MiniDexed
mirror of https://github.com/probonopd/MiniDexed
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fixing effect_mixer.

Browse Source
pull/85/head
Holger Wirtz 3 years ago
parent cefff4799b
commit 0124b248dc
7 changed files with 188 additions and 210 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      src/Makefile
  2. 148
      src/effect_mixer.cpp
  3. 47
      src/effect_mixer.h
  4. 174
      src/effect_mixer.hpp
  5. 1
      src/effect_platervbstereo.h
  6. 24
      src/minidexed.cpp
  7. 2
      src/minidexed.h

2
src/Makefile
Unescape View File

@ -9,7 +9,7 @@ CMSIS_DIR = ../CMSIS_5/CMSIS
OBJS = main.o kernel.o minidexed.o config.o userinterface.o uimenu.o \
mididevice.o midikeyboard.o serialmididevice.o pckeyboard.o \
sysexfileloader.o performanceconfig.o perftimer.o \
effect_mixer.o effect_compressor.o effect_platervbstereo.o
effect_compressor.o effect_platervbstereo.o
include ./Synth_Dexed.mk
include ./Rules.mk

148
src/effect_mixer.cpp
Unescape View File

@ -1,148 +0,0 @@
// Taken from https://github.com/manicken/Audio/tree/templateMixer
// Adapted for MiniDexed by Holger Wirtz <dcoredump@googlemail.com>
#include <cstdlib>
#include <stdint.h>
#include <assert.h>
#include "arm_math.h"
#include "effect_mixer.h"
template <int NN> AudioMixer<NN>::AudioMixer(uint16_t len)
{
buffer_length=len;
for (uint8_t i=0; i<NN; i++)
multiplier[i] = UNITY_GAIN;
sumbufL=(float32_t*)malloc(sizeof(float32_t) * buffer_length);
arm_fill_f32(0.0, sumbufL, len);
}
template <int NN> void AudioMixer<NN>::gain(uint8_t channel, float32_t gain)
{
if (channel >= NN) return;
if (gain > MAX_GAIN)
gain = MAX_GAIN;
else if (gain < MIN_GAIN)
gain = MIN_GAIN;
multiplier[channel] = gain;
}
template <int NN> void AudioMixer<NN>::gain(float32_t gain)
{
for (uint8_t i = 0; i < NN; i++)
{
if (gain > MAX_GAIN)
gain = MAX_GAIN;
else if (gain < MIN_GAIN)
gain = MIN_GAIN;
multiplier[i] = gain;
}
}
template <int NN> void AudioMixer<NN>::doAddMix(uint8_t channel, float32_t* in)
{
float32_t* tmp=malloc(sizeof(float32_t)*buffer_length);
assert(tmp!=NULL);
assert(in);
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(in,multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
free(tmp);
}
template <int NN> void AudioMixer<NN>::getMix(float32_t* buffer)
{
assert(buffer);
assert(sumbufL);
arm_copy_f32(sumbufL, buffer, buffer_length);
if(sumbufL)
arm_fill_f32(0.0, sumbufL, buffer_length);
}
template <int NN> AudioStereoMixer<NN>::AudioStereoMixer(uint16_t len) : AudioMixer<NN>(len)
{
buffer_length=len;
for (uint8_t i=0; i<NN; i++)
panorama[i] = UNITY_PANORAMA;
sumbufR=(float32_t*)malloc(sizeof(float32_t) * buffer_length);
arm_fill_f32(0.0, sumbufR, buffer_length);
}
template <int NN> void AudioStereoMixer<NN>::pan(uint8_t channel, float32_t pan)
{
if (channel >= NN) return;
if (pan > MAX_PANORAMA)
pan = MAX_PANORAMA;
else if (pan < MIN_PANORAMA)
pan = MIN_PANORAMA;
panorama[channel] = pan;
}
template <int NN> void AudioStereoMixer<NN>::doAddMix(uint8_t channel, float32_t* in)
{
float32_t* tmp=malloc(sizeof(float32_t)*buffer_length);
assert(tmp!=NULL);
assert(in);
// left
arm_scale_f32(in, 1.0f-panorama[channel], tmp, buffer_length);
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(tmp,AudioMixer<NN>::multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
// right
arm_scale_f32(in, panorama[channel], tmp, buffer_length);
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(tmp,AudioMixer<NN>::multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufR, tmp, sumbufR, buffer_length);
if(sumbufL)
arm_fill_f32(0.0, sumbufL, buffer_length);
if(sumbufR)
arm_fill_f32(0.0, sumbufR, buffer_length);
free(tmp);
}
template <int NN> void AudioStereoMixer<NN>::doAddMix(uint8_t channel, float32_t* inL, float32_t* inR)
{
float32_t* tmp=malloc(sizeof(float32_t)*buffer_length);
assert(tmp!=NULL);
assert(inL);
assert(inR);
// left
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(inL,AudioMixer<NN>::multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
// right
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(inR,AudioMixer<NN>::multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufR, tmp, sumbufR, buffer_length);
free(tmp);
}
template <int NN> void AudioStereoMixer<NN>::getMix(float32_t* bufferL, float32_t* bufferR)
{
assert(bufferR);
assert(bufferL);
assert(sumbufL);
assert(sumbufR);
arm_copy_f32 (sumbufL, bufferL, buffer_length);
arm_copy_f32 (sumbufR, bufferR, buffer_length);
if(sumbufL)
arm_fill_f32(0.0, sumbufL, buffer_length);
if(sumbufR)
arm_fill_f32(0.0, sumbufR, buffer_length);
}

47
src/effect_mixer.h
Unescape View File

@ -1,47 +0,0 @@
// Taken from https://github.com/manicken/Audio/tree/templateMixer
// Adapted for MiniDexed by Holger Wirtz <dcoredump@googlemail.com>
#ifndef template_mixer_h_
#define template_mixer_h_
#include "arm_math.h"
#include <stdint.h>
#define UNITY_GAIN 1.0f
#define MAX_GAIN 1.0f
#define MIN_GAIN 0.0f
#define UNITY_PANORAMA 1.0f
#define MAX_PANORAMA 1.0f
#define MIN_PANORAMA 0.0f
template <int NN> class AudioMixer
{
public:
AudioMixer(uint16_t len);
void doAddMix(uint8_t channel, float32_t* in);
void gain(uint8_t channel, float32_t gain);
void gain(float32_t gain);
void getMix(float32_t* buffer);
protected:
float32_t multiplier[NN];
float32_t* sumbufL;
uint16_t buffer_length;
};
template <int NN> class AudioStereoMixer : public AudioMixer<NN>
{
public:
AudioStereoMixer(uint16_t len);
void pan(uint8_t channel, float32_t pan);
void doAddMix(uint8_t channel, float32_t* in);
void doAddMix(uint8_t channel, float32_t* inL, float32_t* inR);
void getMix(float32_t* bufferL, float32_t* bufferR);
protected:
using AudioMixer<NN>::sumbufL;
using AudioMixer<NN>::multiplier;
using AudioMixer<NN>::buffer_length;
float32_t panorama[NN];
float32_t* sumbufR;
};
#endif

174
src/effect_mixer.hpp
Unescape View File

@ -0,0 +1,174 @@
// Taken from https://github.com/manicken/Audio/tree/templateMixer
// Adapted for MiniDexed by Holger Wirtz <dcoredump@googlemail.com>
#ifndef effect_mixer_h_
#define effect_mixer_h_
#include <cstdint>
#include <assert.h>
#include "arm_math.h"
#define UNITY_GAIN 1.0f
#define MAX_GAIN 1.0f
#define MIN_GAIN 0.0f
#define UNITY_PANORAMA 1.0f
#define MAX_PANORAMA 1.0f
#define MIN_PANORAMA 0.0f
template <int NN> class AudioMixer
{
public:
AudioMixer(uint16_t len)
{
buffer_length=len;
for (uint8_t i=0; i<NN; i++)
multiplier[i] = UNITY_GAIN;
sumbufL=(float32_t*)malloc(sizeof(float32_t) * buffer_length);
arm_fill_f32(0.0, sumbufL, len);
}
void doAddMix(uint8_t channel, float32_t* in)
{
float32_t* tmp=(float32_t*)malloc(sizeof(float32_t)*buffer_length);
assert(tmp!=NULL);
assert(in);
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(in,multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
free(tmp);
}
void gain(uint8_t channel, float32_t gain)
{
if (channel >= NN) return;
if (gain > MAX_GAIN)
gain = MAX_GAIN;
else if (gain < MIN_GAIN)
gain = MIN_GAIN;
multiplier[channel] = gain;
}
void gain(float32_t gain)
{
for (uint8_t i = 0; i < NN; i++)
{
if (gain > MAX_GAIN)
gain = MAX_GAIN;
else if (gain < MIN_GAIN)
gain = MIN_GAIN;
multiplier[i] = gain;
}
}
void getMix(float32_t* buffer)
{
assert(buffer);
assert(sumbufL);
arm_copy_f32(sumbufL, buffer, buffer_length);
if(sumbufL)
arm_fill_f32(0.0, sumbufL, buffer_length);
}
protected:
float32_t multiplier[NN];
float32_t* sumbufL;
uint16_t buffer_length;
};
template <int NN> class AudioStereoMixer : public AudioMixer<NN>
{
public:
AudioStereoMixer(uint16_t len) : AudioMixer<NN>(len)
{
for (uint8_t i=0; i<NN; i++)
panorama[i] = UNITY_PANORAMA;
sumbufR=(float32_t*)malloc(sizeof(float32_t) * buffer_length);
arm_fill_f32(0.0, sumbufR, buffer_length);
}
void pan(uint8_t channel, float32_t pan)
{
if (channel >= NN) return;
if (pan > MAX_PANORAMA)
pan = MAX_PANORAMA;
else if (pan < MIN_PANORAMA)
pan = MIN_PANORAMA;
panorama[channel] = pan;
}
void doAddMix(uint8_t channel, float32_t* in)
{
float32_t* tmp=(float32_t*)malloc(sizeof(float32_t)*buffer_length);
assert(tmp!=NULL);
assert(in);
// left
arm_scale_f32(in, 1.0f-panorama[channel], tmp, buffer_length);
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(tmp,multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
// right
arm_scale_f32(in, panorama[channel], tmp, buffer_length);
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(tmp,multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufR, tmp, sumbufR, buffer_length);
if(tmp)
free(tmp);
}
void doAddMix(uint8_t channel, float32_t* inL, float32_t* inR)
{
float32_t* tmp=malloc(sizeof(float32_t)*buffer_length);
assert(tmp!=NULL);
assert(inL);
assert(inR);
// left
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(inL,AudioMixer<NN>::multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
// right
if(multiplier[channel]!=UNITY_GAIN)
arm_scale_f32(inR,AudioMixer<NN>::multiplier[channel],tmp,buffer_length);
arm_add_f32(sumbufR, tmp, sumbufR, buffer_length);
if(tmp)
free(tmp);
}
void getMix(float32_t* bufferL, float32_t* bufferR)
{
assert(bufferR);
assert(bufferL);
assert(sumbufL);
assert(sumbufR);
arm_copy_f32 (sumbufL, bufferL, buffer_length);
arm_copy_f32 (sumbufR, bufferR, buffer_length);
if(sumbufL)
arm_fill_f32(0.0, sumbufL, buffer_length);
if(sumbufR)
arm_fill_f32(0.0, sumbufR, buffer_length);
}
protected:
using AudioMixer<NN>::sumbufL;
using AudioMixer<NN>::multiplier;
using AudioMixer<NN>::buffer_length;
float32_t panorama[NN];
float32_t* sumbufR;
};
#endif

1
src/effect_platervbstereo.h
Unescape View File

@ -41,7 +41,6 @@
*
*/
#pragma once
#ifndef _EFFECT_PLATERVBSTEREO_H
#define _EFFECT_PLATERVBSTEREO_H

24
src/minidexed.cpp
Unescape View File

@ -115,7 +115,7 @@ CMiniDexed::CMiniDexed (CConfig *pConfig, CInterruptSystem *pInterrupt,
#endif
// BEGIN setup tg_mixer
tg_mixer = new AudioStereoMixer<8>(pConfig->GetChunkSize());
tg_mixer = new AudioStereoMixer<8>(pConfig->GetChunkSize()/2);
// END setup tgmixer
// BEGIN setup reverb
@ -162,6 +162,8 @@ bool CMiniDexed::Initialize (void)
m_pTG[i]->setPBController (12, 1);
m_pTG[i]->setMWController (99, 7, 0);
tg_mixer->pan(i,m_fPan[i]);
}
if (m_PerformanceConfig.Load ())
@ -747,37 +749,35 @@ void CMiniDexed::ProcessSound (void)
// Audio signal path after tone generators starts here
//
// now mix the output of all TGs
uint8_t indexL=0, indexR=1;
assert (CConfig::ToneGenerators == 8);
// swap stereo channels if needed
uint8_t indexL=0, indexR=1;
if (m_bChannelsSwapped)
{
indexL=1;
indexR=0;
}
assert (CConfig::ToneGenerators == 8);
// BEGIN stereo panorama and TG mixing
// BEGIN TG mixing
for (uint8_t i = 0; i < CConfig::ToneGenerators; i++)
{
tg_mixer->pan(i,m_fPan[i]);
tg_mixer->doAddMix(i,m_OutputLevel[i]);
}
// END stereo panorama and TG mixing
// END TG mixing
// BEGIN adding reverb
// BEGIN create SampleBuffer for holding audio data
float32_t SampleBuffer[2][nFrames];
// init left sum output
assert (SampleBuffer[0]!=NULL);
arm_fill_f32(0.0, SampleBuffer[0], nFrames);
// init right sum output
assert (SampleBuffer[1]!=NULL);
arm_fill_f32(0.0, SampleBuffer[1], nFrames);
// END create SampleBuffer for holding audio data
// get the mix of all TGs
tg_mixer->getMix(SampleBuffer[indexL], SampleBuffer[indexR]);
// BEGIN adding reverb
if (m_nParameter[ParameterReverbEnable])
{
float32_t ReverbBuffer[2][nFrames];

2
src/minidexed.h
Unescape View File

@ -40,9 +40,9 @@
#include <circle/soundbasedevice.h>
#include <circle/spinlock.h>
#include "common.h"
#include "effect_mixer.hpp"
#include "effect_platervbstereo.h"
#include "effect_compressor.h"
#include "effect_mixer.h"
class CMiniDexed
#ifdef ARM_ALLOW_MULTI_CORE

Write Preview
Loading…
Cancel
Save