442 lines
12 KiB
C++
442 lines
12 KiB
C++
/*
|
|
Copyright (C) 2009 Nasca Octavian Paul
|
|
Author: Nasca Octavian Paul
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of version 2 of the GNU General Public License
|
|
as published by the Free Software Foundation.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License (version 2) for more details.
|
|
|
|
You should have received a copy of the GNU General Public License (version 2)
|
|
along with this program; if not, write to the Free Software Foundation,
|
|
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "ProcessedStretch.h"
|
|
|
|
ProcessedStretch::ProcessedStretch(REALTYPE rap_,int in_bufsize_,FFTWindow w,bool bypass_,REALTYPE samplerate_,int stereo_mode_)
|
|
: Stretch(rap_,in_bufsize_,w,bypass_,samplerate_,stereo_mode_)
|
|
{
|
|
|
|
|
|
};
|
|
|
|
ProcessedStretch::~ProcessedStretch()
|
|
{
|
|
|
|
// delete [] fbfreq;
|
|
};
|
|
|
|
void ProcessedStretch::set_parameters(ProcessParameters *ppar)
|
|
{
|
|
pars=*ppar;
|
|
//update_free_filter();
|
|
}
|
|
void ProcessedStretch::setBufferSize(int sz)
|
|
{
|
|
Stretch::setBufferSize(sz);
|
|
nfreq = bufsize;
|
|
infreq = floatvector(nfreq);
|
|
sumfreq = floatvector(nfreq);
|
|
tmpfreq1 = floatvector(nfreq);
|
|
tmpfreq2 = floatvector(nfreq);
|
|
//fbfreq=new REALTYPE[nfreq];
|
|
free_filter_freqs = floatvector(nfreq);
|
|
for (int i = 0; i<nfreq; i++) {
|
|
free_filter_freqs[i] = 1.0;
|
|
// fbfreq[i]=0.0;
|
|
};
|
|
}
|
|
|
|
|
|
/*
|
|
void ProcessedStretch::copy(const realvector& freq1,realvector& freq2)
|
|
{
|
|
for (int i=0;i<nfreq;i++) freq2[i]=freq1[i];
|
|
};
|
|
*/
|
|
|
|
void ProcessedStretch::copy(REALTYPE* freq1, REALTYPE* freq2)
|
|
{
|
|
for (int i = 0; i<nfreq; i++) freq2[i] = freq1[i];
|
|
};
|
|
|
|
void ProcessedStretch::add(REALTYPE *freq2,REALTYPE *freq1,REALTYPE a){
|
|
for (int i=0;i<nfreq;i++) freq2[i]+=freq1[i]*a;
|
|
};
|
|
|
|
void ProcessedStretch::mul(REALTYPE *freq1,REALTYPE a){
|
|
for (int i=0;i<nfreq;i++) freq1[i]*=a;
|
|
};
|
|
|
|
void ProcessedStretch::zero(REALTYPE *freq1){
|
|
for (int i=0;i<nfreq;i++) freq1[i]=0.0;
|
|
};
|
|
|
|
REALTYPE ProcessedStretch::get_stretch_multiplier(REALTYPE pos_percents){
|
|
REALTYPE result=1.0;
|
|
/*
|
|
if (pars.stretch_multiplier.get_enabled()){
|
|
result*=pars.stretch_multiplier.get_value(pos_percents);
|
|
};
|
|
*/
|
|
///REALTYPE transient=pars.get_transient(pos_percents);
|
|
///printf("\n%g\n",transient);
|
|
///REALTYPE threshold=0.05;
|
|
///REALTYPE power=1000.0;
|
|
///transient-=threshold;
|
|
///if (transient>0){
|
|
/// transient*=power*(1.0+power);
|
|
/// result/=(1.0+transient);
|
|
///};
|
|
///printf("tr=%g\n",result);
|
|
return result;
|
|
};
|
|
|
|
void ProcessedStretch::process_spectrum(REALTYPE *freq)
|
|
{
|
|
for (auto& e : m_spectrum_processes)
|
|
{
|
|
spectrum_copy(nfreq, freq, infreq.data());
|
|
if (e == 0 && pars.harmonics.enabled)
|
|
spectrum_do_harmonics(pars, tmpfreq1, nfreq, samplerate, infreq.data(), freq);
|
|
if (e == 1 && pars.tonal_vs_noise.enabled)
|
|
spectrum_do_tonal_vs_noise(pars,nfreq,samplerate,tmpfreq1, infreq.data(), freq);
|
|
if (e == 2 && pars.freq_shift.enabled)
|
|
spectrum_do_freq_shift(pars,nfreq,samplerate,infreq.data(), freq);
|
|
if (e == 3 && pars.pitch_shift.enabled)
|
|
spectrum_do_pitch_shift(pars,nfreq,infreq.data(), freq, pow(2.0f, pars.pitch_shift.cents / 1200.0f));
|
|
if (e == 4 && pars.octave.enabled)
|
|
spectrum_do_octave(pars,nfreq,samplerate, sumfreq, tmpfreq1, infreq.data(), freq);
|
|
if (e == 5 && pars.spread.enabled)
|
|
spectrum_spread(nfreq,samplerate,tmpfreq1,infreq.data(), freq, pars.spread.bandwidth);
|
|
if (e == 6 && pars.filter.enabled)
|
|
spectrum_do_filter(pars,nfreq,samplerate,infreq.data(), freq);
|
|
if (e == 7 && pars.compressor.enabled)
|
|
spectrum_do_compressor(pars,nfreq, infreq.data(), freq);
|
|
}
|
|
|
|
#ifdef USE_OLD_SPEC_PROC
|
|
if (pars.harmonics.enabled) {
|
|
copy(freq,infreq.data());
|
|
do_harmonics(infreq.data(),freq);
|
|
};
|
|
|
|
if (pars.tonal_vs_noise.enabled){
|
|
copy(freq,infreq.data());
|
|
do_tonal_vs_noise(infreq.data(),freq);
|
|
};
|
|
|
|
if (pars.freq_shift.enabled) {
|
|
copy(freq,infreq.data());
|
|
do_freq_shift(infreq.data(),freq);
|
|
};
|
|
if (pars.pitch_shift.enabled) {
|
|
copy(freq,infreq.data());
|
|
do_pitch_shift(infreq.data(),freq,pow(2.0,pars.pitch_shift.cents/1200.0));
|
|
};
|
|
if (pars.octave.enabled){
|
|
copy(freq,infreq.data());
|
|
do_octave(infreq.data(),freq);
|
|
};
|
|
|
|
|
|
if (pars.spread.enabled){
|
|
copy(freq,infreq.data());
|
|
do_spread(infreq.data(),freq);
|
|
};
|
|
|
|
|
|
if (pars.filter.enabled){
|
|
copy(freq,infreq.data());
|
|
do_filter(infreq.data(),freq);
|
|
};
|
|
|
|
if (pars.free_filter.get_enabled()){
|
|
copy(freq,infreq.data());
|
|
do_free_filter(infreq.data(),freq);
|
|
};
|
|
|
|
if (pars.compressor.enabled){
|
|
copy(freq,infreq.data());
|
|
do_compressor(infreq.data(),freq);
|
|
};
|
|
#endif
|
|
};
|
|
|
|
//void ProcessedStretch::process_output(REALTYPE *smps,int nsmps){
|
|
//};
|
|
|
|
void ProcessedStretch::do_harmonics(REALTYPE *freq1,REALTYPE *freq2){
|
|
REALTYPE freq=pars.harmonics.freq;
|
|
REALTYPE bandwidth=pars.harmonics.bandwidth;
|
|
int nharmonics=pars.harmonics.nharmonics;
|
|
|
|
if (freq<10.0) freq=10.0;
|
|
|
|
REALTYPE *amp=tmpfreq1.data();
|
|
for (int i=0;i<nfreq;i++) amp[i]=0.0;
|
|
|
|
for (int nh=1;nh<=nharmonics;nh++){//for each harmonic
|
|
REALTYPE bw_Hz;//bandwidth of the current harmonic measured in Hz
|
|
REALTYPE bwi;
|
|
REALTYPE fi;
|
|
REALTYPE f=nh*freq;
|
|
|
|
if (f>=samplerate/2) break;
|
|
|
|
bw_Hz=(pow(2.0f,bandwidth/1200.0f)-1.0f)*f;
|
|
bwi=bw_Hz/(2.0f*samplerate);
|
|
fi=f/samplerate;
|
|
|
|
REALTYPE sum=0.0f;
|
|
REALTYPE max=0.0f;
|
|
for (int i=1;i<nfreq;i++){//todo: optimize here
|
|
REALTYPE hprofile;
|
|
hprofile=profile((i/(REALTYPE)nfreq*0.5f)-fi,bwi);
|
|
amp[i]+=hprofile;
|
|
if (max<hprofile) max=hprofile;
|
|
sum+=hprofile;
|
|
};
|
|
};
|
|
|
|
REALTYPE max=0.0;
|
|
for (int i=1;i<nfreq;i++){
|
|
if (amp[i]>max) max=amp[i];
|
|
};
|
|
if (max<1e-8f) max=1e-8f;
|
|
|
|
for (int i=1;i<nfreq;i++){
|
|
//REALTYPE c,s;
|
|
REALTYPE a=amp[i]/max;
|
|
if (!pars.harmonics.gauss) a=(a<0.368f?0.0f:1.0f);
|
|
freq2[i]=freq1[i]*a;
|
|
};
|
|
|
|
};
|
|
|
|
|
|
void ProcessedStretch::do_freq_shift(REALTYPE *freq1,REALTYPE *freq2){
|
|
zero(freq2);
|
|
int ifreq=(int)(pars.freq_shift.Hz/(samplerate*0.5)*nfreq);
|
|
for (int i=0;i<nfreq;i++){
|
|
int i2=ifreq+i;
|
|
if ((i2>0)&&(i2<nfreq)) freq2[i2]=freq1[i];
|
|
};
|
|
};
|
|
void ProcessedStretch::do_pitch_shift(REALTYPE *freq1,REALTYPE *freq2,REALTYPE _rap){
|
|
zero(freq2);
|
|
if (_rap<1.0){//down
|
|
for (int i=0;i<nfreq;i++){
|
|
int i2=(int)(i*_rap);
|
|
if (i2>=nfreq) break;
|
|
freq2[i2]+=freq1[i];
|
|
};
|
|
};
|
|
if (_rap>=1.0){//up
|
|
_rap=1.0f/_rap;
|
|
for (int i=0;i<nfreq;i++){
|
|
freq2[i]=freq1[(int)(i*_rap)];
|
|
};
|
|
|
|
};
|
|
};
|
|
void ProcessedStretch::do_octave(REALTYPE *freq1,REALTYPE *freq2){
|
|
zero(sumfreq.data());
|
|
if (pars.octave.om2>1e-3){
|
|
do_pitch_shift(freq1,tmpfreq1.data(),0.25);
|
|
add(sumfreq.data(),tmpfreq1.data(),pars.octave.om2);
|
|
};
|
|
if (pars.octave.om1>1e-3){
|
|
do_pitch_shift(freq1,tmpfreq1.data(),0.5);
|
|
add(sumfreq.data(),tmpfreq1.data(),pars.octave.om1);
|
|
};
|
|
if (pars.octave.o0>1e-3){
|
|
add(sumfreq.data(),freq1,pars.octave.o0);
|
|
};
|
|
if (pars.octave.o1>1e-3){
|
|
do_pitch_shift(freq1,tmpfreq1.data(),2.0);
|
|
add(sumfreq.data(),tmpfreq1.data(),pars.octave.o1);
|
|
};
|
|
if (pars.octave.o15>1e-3){
|
|
do_pitch_shift(freq1,tmpfreq1.data(),3.0);
|
|
add(sumfreq.data(),tmpfreq1.data(),pars.octave.o15);
|
|
};
|
|
if (pars.octave.o2>1e-3){
|
|
do_pitch_shift(freq1,tmpfreq1.data(),4.0);
|
|
add(sumfreq.data(),tmpfreq1.data(),pars.octave.o2);
|
|
};
|
|
|
|
REALTYPE sum=0.01f+pars.octave.om2+pars.octave.om1+pars.octave.o0+pars.octave.o1+pars.octave.o15+pars.octave.o2;
|
|
if (sum<0.5f) sum=0.5f;
|
|
for (int i=0;i<nfreq;i++) freq2[i]=sumfreq[i]/sum;
|
|
};
|
|
|
|
void ProcessedStretch::do_filter(REALTYPE *freq1,REALTYPE *freq2){
|
|
REALTYPE low=0,high=0;
|
|
if (pars.filter.low<pars.filter.high){//sort the low/high freqs
|
|
low=pars.filter.low;
|
|
high=pars.filter.high;
|
|
}else{
|
|
high=pars.filter.low;
|
|
low=pars.filter.high;
|
|
};
|
|
int ilow=(int) (low/samplerate*nfreq*2.0f);
|
|
int ihigh=(int) (high/samplerate*nfreq*2.0f);
|
|
REALTYPE dmp=1.0;
|
|
REALTYPE dmprap=1.0f-pow(pars.filter.hdamp*0.5f,4.0f);
|
|
for (int i=0;i<nfreq;i++){
|
|
REALTYPE a=0.0f;
|
|
if ((i>=ilow)&&(i<ihigh)) a=1.0f;
|
|
if (pars.filter.stop) a=1.0f-a;
|
|
freq2[i]=freq1[i]*a*dmp;
|
|
dmp*=dmprap+1e-8f;
|
|
};
|
|
};
|
|
|
|
void ProcessedStretch::update_free_filter()
|
|
{
|
|
/*
|
|
pars.free_filter.update_curve();
|
|
if (pars.free_filter.get_enabled()) {
|
|
for (int i=0;i<nfreq;i++){
|
|
REALTYPE freq=(REALTYPE)i/(REALTYPE) nfreq*samplerate*0.5f;
|
|
free_filter_freqs[i]=pars.free_filter.get_value(freq);
|
|
};
|
|
}else{
|
|
for (int i=0;i<nfreq;i++){
|
|
free_filter_freqs[i]=1.0f;
|
|
};
|
|
};
|
|
*/
|
|
};
|
|
|
|
void ProcessedStretch::do_free_filter(REALTYPE *freq1,REALTYPE *freq2){
|
|
for (int i=0;i<nfreq;i++){
|
|
freq2[i]=freq1[i]*free_filter_freqs[i];
|
|
};
|
|
};
|
|
|
|
void ProcessedStretch::do_spread(REALTYPE *freq1,REALTYPE *freq2){
|
|
spread(freq1,freq2,pars.spread.bandwidth);
|
|
};
|
|
|
|
void ProcessedStretch::spread(REALTYPE *freq1,REALTYPE *freq2,REALTYPE spread_bandwidth){
|
|
//convert to log spectrum
|
|
REALTYPE minfreq=20.0f;
|
|
REALTYPE maxfreq=0.5f*samplerate;
|
|
|
|
REALTYPE log_minfreq=log(minfreq);
|
|
REALTYPE log_maxfreq=log(maxfreq);
|
|
|
|
for (int i=0;i<nfreq;i++){
|
|
REALTYPE freqx=i/(REALTYPE) nfreq;
|
|
REALTYPE x=exp(log_minfreq+freqx*(log_maxfreq-log_minfreq))/maxfreq*nfreq;
|
|
REALTYPE y=0.0f;
|
|
int x0=(int)floor(x); if (x0>=nfreq) x0=nfreq-1;
|
|
int x1=x0+1; if (x1>=nfreq) x1=nfreq-1;
|
|
REALTYPE xp=x-x0;
|
|
if (x<nfreq){
|
|
y=freq1[x0]*(1.0f-xp)+freq1[x1]*xp;
|
|
};
|
|
tmpfreq1[i]=y;
|
|
};
|
|
|
|
//increase the bandwidth of each harmonic (by smoothing the log spectrum)
|
|
int n=2;
|
|
REALTYPE bandwidth=spread_bandwidth;
|
|
REALTYPE a=1.0f-pow(2.0f,-bandwidth*bandwidth*10.0f);
|
|
a=pow(a,8192.0f/nfreq*n);
|
|
|
|
for (int k=0;k<n;k++){
|
|
tmpfreq1[0]=0.0f;
|
|
for (int i=1;i<nfreq;i++){
|
|
tmpfreq1[i]=tmpfreq1[i-1]*a+tmpfreq1[i]*(1.0f-a);
|
|
};
|
|
tmpfreq1[nfreq-1]=0.0f;
|
|
for (int i=nfreq-2;i>0;i--){
|
|
tmpfreq1[i]=tmpfreq1[i+1]*a+tmpfreq1[i]*(1.0f-a);
|
|
};
|
|
};
|
|
|
|
freq2[0]=0;
|
|
REALTYPE log_maxfreq_d_minfreq=log(maxfreq/minfreq);
|
|
for (int i=1;i<nfreq;i++){
|
|
REALTYPE freqx=i/(REALTYPE) nfreq;
|
|
REALTYPE x=log((freqx*maxfreq)/minfreq)/log_maxfreq_d_minfreq*nfreq;
|
|
REALTYPE y=0.0;
|
|
if ((x>0.0)&&(x<nfreq)){
|
|
int x0=(int)floor(x); if (x0>=nfreq) x0=nfreq-1;
|
|
int x1=x0+1; if (x1>=nfreq) x1=nfreq-1;
|
|
REALTYPE xp=x-x0;
|
|
y=tmpfreq1[x0]*(1.0f-xp)+tmpfreq1[x1]*xp;
|
|
};
|
|
freq2[i]=y;
|
|
};
|
|
|
|
|
|
};
|
|
|
|
|
|
void ProcessedStretch::do_compressor(REALTYPE *freq1,REALTYPE *freq2){
|
|
REALTYPE rms=0.0;
|
|
for (int i=0;i<nfreq;i++) rms+=freq1[i]*freq1[i];
|
|
rms=sqrt(rms/nfreq)*0.1f;
|
|
if (rms<1e-3f) rms=1e-3f;
|
|
|
|
REALTYPE _rap=pow(rms,-pars.compressor.power);
|
|
for (int i=0;i<nfreq;i++) freq2[i]=freq1[i]*_rap;
|
|
};
|
|
|
|
void ProcessedStretch::do_tonal_vs_noise(REALTYPE *freq1,REALTYPE *freq2){
|
|
spread(freq1,tmpfreq1.data(),pars.tonal_vs_noise.bandwidth);
|
|
|
|
if (pars.tonal_vs_noise.preserve>=0.0){
|
|
REALTYPE mul=(pow(10.0f,pars.tonal_vs_noise.preserve)-1.0f);
|
|
for (int i=0;i<nfreq;i++) {
|
|
REALTYPE x=freq1[i];
|
|
REALTYPE smooth_x=tmpfreq1[i]+1e-6f;
|
|
|
|
REALTYPE result=0.0f;
|
|
result=x-smooth_x*mul;
|
|
if (result<0.0f) result=0.0f;
|
|
freq2[i]=result;
|
|
};
|
|
}else{
|
|
REALTYPE mul=(pow(5.0f,1.0f+pars.tonal_vs_noise.preserve)-1.0f);
|
|
for (int i=0;i<nfreq;i++) {
|
|
REALTYPE x=freq1[i];
|
|
REALTYPE smooth_x=tmpfreq1[i]+1e-6f;
|
|
|
|
REALTYPE result=0.0f;
|
|
result=x-smooth_x*mul+0.1f*mul;
|
|
if (result<0.0f) result=x;
|
|
else result=0.0f;
|
|
|
|
freq2[i]=result;
|
|
};
|
|
};
|
|
|
|
};
|
|
|
|
std::vector<SpectrumProcess> make_spectrum_processes()
|
|
{
|
|
std::vector<SpectrumProcess> m_spectrum_processes;
|
|
m_spectrum_processes.emplace_back("Harmonics",0);
|
|
m_spectrum_processes.emplace_back("Tonal vs Noise",1);
|
|
m_spectrum_processes.emplace_back("Frequency shift",2);
|
|
m_spectrum_processes.emplace_back("Pitch shift",3);
|
|
m_spectrum_processes.emplace_back("Octaves mix",4);
|
|
m_spectrum_processes.emplace_back("Spread",5);
|
|
m_spectrum_processes.emplace_back("Filter",6);
|
|
m_spectrum_processes.emplace_back("Compressor",7);
|
|
return m_spectrum_processes;
|
|
}
|