Soundship
/
Loopp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Use stereo signal for all channels

main
coderkun 2017-03-19 15:58:28 +01:00 committed by Harry van Haaren
parent 59b146f052
commit 9b7cb506d5
8 changed files with 320 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

117
src/buffers.hxx
View File

@ -34,20 +34,27 @@ public:
MASTER_OUT_L,
MASTER_OUT_R,
JACK_SEND_OUT,
JACK_SEND_OUT_L,
JACK_SEND_OUT_R,
JACK_MASTER_OUT_L,
JACK_MASTER_OUT_R,
JACK_SIDECHAIN_KEY,
JACK_SIDECHAIN_SIGNAL,
JACK_SIDECHAIN_KEY_L,
JACK_SIDECHAIN_KEY_R,
JACK_SIDECHAIN_SIGNAL_L,
JACK_SIDECHAIN_SIGNAL_R,
SEND,
SIDECHAIN_KEY,
SIDECHAIN_SIGNAL,
SEND_L,
SEND_R,
SIDECHAIN_KEY_L,
SIDECHAIN_KEY_R,
SIDECHAIN_SIGNAL_L,
SIDECHAIN_SIGNAL_R,
MASTER_RETURN_L,
MASTER_RETURN_R,
HEADPHONES_OUT,
HEADPHONES_OUT_L,
HEADPHONES_OUT_R,
// MIDI
MASTER_MIDI_INPUT,
@ -55,40 +62,72 @@ public:
// track buffers: they are the "working" buffers per track:
// the end result is mixed into the master output, while each
// stage along the way the amplitude etc can be analysed
TRACK_0,
TRACK_1,
TRACK_2,
TRACK_3,
TRACK_4,
TRACK_5,
TRACK_6,
TRACK_7,
TRACK_0_L,
TRACK_0_R,
TRACK_1_L,
TRACK_1_R,
TRACK_2_L,
TRACK_2_R,
TRACK_3_L,
TRACK_3_R,
TRACK_4_L,
TRACK_4_R,
TRACK_5_L,
TRACK_5_R,
TRACK_6_L,
TRACK_6_R,
TRACK_7_L,
TRACK_7_R,
//Per track sends/returns
SEND_TRACK_0,
SEND_TRACK_1,
SEND_TRACK_2,
SEND_TRACK_3,
SEND_TRACK_4,
SEND_TRACK_5,
SEND_TRACK_6,
SEND_TRACK_7,
RETURN_TRACK_0,
RETURN_TRACK_1,
RETURN_TRACK_2,
RETURN_TRACK_3,
RETURN_TRACK_4,
RETURN_TRACK_5,
RETURN_TRACK_6,
RETURN_TRACK_7,
SEND_TRACK_0_L,
SEND_TRACK_0_R,
SEND_TRACK_1_L,
SEND_TRACK_1_R,
SEND_TRACK_2_L,
SEND_TRACK_2_R,
SEND_TRACK_3_L,
SEND_TRACK_3_R,
SEND_TRACK_4_L,
SEND_TRACK_4_R,
SEND_TRACK_5_L,
SEND_TRACK_5_R,
SEND_TRACK_6_L,
SEND_TRACK_6_R,
SEND_TRACK_7_L,
SEND_TRACK_7_R,
RETURN_TRACK_0_L,
RETURN_TRACK_0_R,
RETURN_TRACK_1_L,
RETURN_TRACK_1_R,
RETURN_TRACK_2_L,
RETURN_TRACK_2_R,
RETURN_TRACK_3_L,
RETURN_TRACK_3_R,
RETURN_TRACK_4_L,
RETURN_TRACK_4_R,
RETURN_TRACK_5_L,
RETURN_TRACK_5_R,
RETURN_TRACK_6_L,
RETURN_TRACK_6_R,
RETURN_TRACK_7_L,
RETURN_TRACK_7_R,
JACK_TRACK_0,
JACK_TRACK_1,
JACK_TRACK_2,
JACK_TRACK_3,
JACK_TRACK_4,
JACK_TRACK_5,
JACK_TRACK_6,
JACK_TRACK_7,
JACK_TRACK_0_L,
JACK_TRACK_0_R,
JACK_TRACK_1_L,
JACK_TRACK_1_R,
JACK_TRACK_2_L,
JACK_TRACK_2_R,
JACK_TRACK_3_L,
JACK_TRACK_3_R,
JACK_TRACK_4_L,
JACK_TRACK_4_R,
JACK_TRACK_5_L,
JACK_TRACK_5_R,
JACK_TRACK_6_L,
JACK_TRACK_6_R,
JACK_TRACK_7_L,
JACK_TRACK_7_R,
BUFFER_COUNT,

223
src/jack.cxx
View File

@ -145,29 +145,53 @@ Jack::Jack( std::string name ) :
JackPortIsOutput,
0 );
headphonesPort = jack_port_register( client,
"headphone_out",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
headphonesPortL = jack_port_register( client,
"headphone_out_l",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sendOutput = jack_port_register( client,
"send_out",
headphonesPortR = jack_port_register( client,
"headphone_out_r",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sendOutputL = jack_port_register( client,
"send_out_l",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sidechainKeyOutput= jack_port_register( client,
"sidechain_key",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sendOutputR = jack_port_register( client,
"send_out_r",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sidechainSignalOutput= jack_port_register( client,
"sidechain_signal",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sidechainKeyOutputL = jack_port_register( client,
"sidechain_key_l",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sidechainKeyOutputR = jack_port_register( client,
"sidechain_key_r",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sidechainSignalOutputL = jack_port_register( client,
"sidechain_signal_l",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sidechainSignalOutputR = jack_port_register( client,
"sidechain_signal_r",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
/*
masterMidiInput = jack_port_register( client,
@ -188,9 +212,12 @@ Jack::Jack( std::string name ) :
inputToXSideVol = 0.f;
/// prepare internal buffers
buffers.audio[Buffers::SEND] = new float[ buffers.nframes ];
buffers.audio[Buffers::SIDECHAIN_KEY] = new float[ buffers.nframes ];
buffers.audio[Buffers::SIDECHAIN_SIGNAL]=new float[ buffers.nframes ];
buffers.audio[Buffers::SEND_L] = new float[ buffers.nframes ];
buffers.audio[Buffers::SEND_R] = new float[ buffers.nframes ];
buffers.audio[Buffers::SIDECHAIN_KEY_L] = new float[ buffers.nframes ];
buffers.audio[Buffers::SIDECHAIN_KEY_R] = new float[ buffers.nframes ];
buffers.audio[Buffers::SIDECHAIN_SIGNAL_L]= new float[ buffers.nframes ];
buffers.audio[Buffers::SIDECHAIN_SIGNAL_R]= new float[ buffers.nframes ];
buffers.audio[Buffers::MASTER_OUT_L] = new float[ buffers.nframes ];
buffers.audio[Buffers::MASTER_OUT_R] = new float[ buffers.nframes ];
@ -207,19 +234,29 @@ Jack::Jack( std::string name ) :
tracksendreturns.push_back(new JackSendReturn(i,loopers.back(),client));
trackOutputs.push_back( new TrackOutput(i, tracksendreturns.back() ) );
buffers.audio[Buffers::TRACK_0 + i] = new float[ buffers.nframes ];
buffers.audio[Buffers::SEND_TRACK_0+i]=new float[buffers.nframes];
buffers.audio[Buffers::RETURN_TRACK_0+i]=new float[buffers.nframes];
int o = i*2;
buffers.audio[Buffers::TRACK_0_L + o] = new float[ buffers.nframes ];
buffers.audio[Buffers::TRACK_0_R + o] = new float[ buffers.nframes ];
buffers.audio[Buffers::SEND_TRACK_0_L+o]=new float[buffers.nframes];
buffers.audio[Buffers::SEND_TRACK_0_R+o]=new float[buffers.nframes];
buffers.audio[Buffers::RETURN_TRACK_0_L+o]=new float[buffers.nframes];
buffers.audio[Buffers::RETURN_TRACK_0_R+o]=new float[buffers.nframes];
timeManager->registerObserver( loopers.back() );
if(gui->enablePerTrackOutput) {
char name[50];
sprintf(name,"track_%d\n",i);
trackJackOutputPorts[i]=jack_port_register( client,
sprintf(name,"track_%d_l",i);
trackJackOutputPorts[o]=jack_port_register( client,
name,
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sprintf(name,"track_%d_r",i);
trackJackOutputPorts[o+1]=jack_port_register( client,
name,
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
}
}
@ -278,9 +315,13 @@ Jack::~Jack()
delete inputMeter;
delete masterMeter;
for(int i = 0; i < NTRACKS; i++) {
delete [] buffers.audio[Buffers::TRACK_0+i];
delete [] buffers.audio[Buffers::SEND_TRACK_0+i];
delete [] buffers.audio[Buffers::RETURN_TRACK_0+i];
int o = i*2;
delete [] buffers.audio[Buffers::TRACK_0_L+o];
delete [] buffers.audio[Buffers::TRACK_0_R+o];
delete [] buffers.audio[Buffers::SEND_TRACK_0_L+o];
delete [] buffers.audio[Buffers::SEND_TRACK_0_R+o];
delete [] buffers.audio[Buffers::RETURN_TRACK_0_L+o];
delete [] buffers.audio[Buffers::RETURN_TRACK_0_R+o];
delete tracksendreturns[i];
delete loopers[i];
delete trackOutputs[i];
@ -309,7 +350,7 @@ void Jack::quit()
TrackOutput* Jack::getTrackOutput(int t)
{
if ( t >= 0 && t < NTRACKS )
if ( t >= 0 && t < NTRACKS*2 )
return trackOutputs.at(t);
#ifdef DEBUG_TRACKS
else {
@ -322,7 +363,7 @@ TrackOutput* Jack::getTrackOutput(int t)
JackSendReturn* Jack::getJackSendReturn(int t)
{
if ( t >= 0 && t < NTRACKS )
if ( t >= 0 && t < NTRACKS*2 )
return tracksendreturns.at(t);
#ifdef DEBUG_TRACKS
else {
@ -336,7 +377,7 @@ JackSendReturn* Jack::getJackSendReturn(int t)
Looper* Jack::getLooper(int t)
{
if ( t >= 0 && t < NTRACKS )
if ( t >= 0 && t < NTRACKS*2 )
return loopers.at(t);
#ifdef DEBUG_TRACKS
else {
@ -373,21 +414,27 @@ void Jack::unregisterMidiIO( MidiIO* mo )
int Jack::process (jack_nframes_t nframes)
{
/// get buffers
buffers.audio[Buffers::MASTER_INPUT_L] = (float*)jack_port_get_buffer( masterInputL , nframes );
buffers.audio[Buffers::MASTER_INPUT_R] = (float*)jack_port_get_buffer( masterInputR , nframes );
buffers.audio[Buffers::MASTER_RETURN_L] = (float*)jack_port_get_buffer( masterReturnL , nframes );
buffers.audio[Buffers::MASTER_RETURN_R] = (float*)jack_port_get_buffer( masterReturnR , nframes );
buffers.audio[Buffers::HEADPHONES_OUT] = (float*)jack_port_get_buffer( headphonesPort , nframes );
buffers.audio[Buffers::MASTER_INPUT_L] = (float*)jack_port_get_buffer( masterInputL, nframes );
buffers.audio[Buffers::MASTER_INPUT_R] = (float*)jack_port_get_buffer( masterInputR, nframes );
buffers.audio[Buffers::MASTER_RETURN_L] = (float*)jack_port_get_buffer( masterReturnL, nframes );
buffers.audio[Buffers::MASTER_RETURN_R] = (float*)jack_port_get_buffer( masterReturnR, nframes );
buffers.audio[Buffers::HEADPHONES_OUT_L] = (float*)jack_port_get_buffer( headphonesPortL, nframes );
buffers.audio[Buffers::HEADPHONES_OUT_R] = (float*)jack_port_get_buffer( headphonesPortR, nframes );
buffers.audio[Buffers::JACK_SEND_OUT] = (float*)jack_port_get_buffer( sendOutput , nframes );
buffers.audio[Buffers::JACK_MASTER_OUT_L] = (float*)jack_port_get_buffer( masterOutputL , nframes );
buffers.audio[Buffers::JACK_MASTER_OUT_R] = (float*)jack_port_get_buffer( masterOutputR , nframes );
buffers.audio[Buffers::JACK_SIDECHAIN_KEY] = (float*)jack_port_get_buffer(sidechainKeyOutput,nframes);
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL]=(float*)jack_port_get_buffer(sidechainSignalOutput,nframes);
buffers.audio[Buffers::JACK_SEND_OUT_L] = (float*)jack_port_get_buffer( sendOutputL, nframes );
buffers.audio[Buffers::JACK_SEND_OUT_R] = (float*)jack_port_get_buffer( sendOutputR, nframes );
buffers.audio[Buffers::JACK_MASTER_OUT_L] = (float*)jack_port_get_buffer( masterOutputL, nframes );
buffers.audio[Buffers::JACK_MASTER_OUT_R] = (float*)jack_port_get_buffer( masterOutputR, nframes );
buffers.audio[Buffers::JACK_SIDECHAIN_KEY_L] = (float*)jack_port_get_buffer( sidechainKeyOutputL, nframes );
buffers.audio[Buffers::JACK_SIDECHAIN_KEY_R] = (float*)jack_port_get_buffer( sidechainKeyOutputR, nframes );
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL_L]= (float*)jack_port_get_buffer( sidechainSignalOutputL,nframes );
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL_R]= (float*)jack_port_get_buffer( sidechainSignalOutputR,nframes );
if(gui->enablePerTrackOutput) {
for(int t=0; t<NTRACKS; t++)
buffers.audio[Buffers::JACK_TRACK_0+t] = (float*)jack_port_get_buffer( trackJackOutputPorts[t] , nframes );
for(int t=0; t<NTRACKS; t++) {
int o = t*2;
buffers.audio[Buffers::JACK_TRACK_0_L+o] = (float*)jack_port_get_buffer( trackJackOutputPorts[o], nframes );
buffers.audio[Buffers::JACK_TRACK_0_R+o] = (float*)jack_port_get_buffer( trackJackOutputPorts[o+1], nframes );
}
}
@ -396,14 +443,20 @@ int Jack::process (jack_nframes_t nframes)
memset( buffers.audio[Buffers::JACK_MASTER_OUT_R] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::MASTER_OUT_L] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::MASTER_OUT_R] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::HEADPHONES_OUT] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SEND] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SIDECHAIN_KEY] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SIDECHAIN_SIGNAL] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::HEADPHONES_OUT_L] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::HEADPHONES_OUT_R] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SEND_L] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SEND_R] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SIDECHAIN_KEY_L] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SIDECHAIN_KEY_R] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SIDECHAIN_SIGNAL_L], 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SIDECHAIN_SIGNAL_R], 0, sizeof(float) * nframes );
if(gui->enablePerTrackOutput) {
for(int t=0; t<NTRACKS; t++)
memset( buffers.audio[Buffers::JACK_TRACK_0+t] , 0, sizeof(float) * nframes );
for(int t=0; t<NTRACKS; t++) {
int o = t*2;
memset( buffers.audio[Buffers::JACK_TRACK_0_L+o], 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::JACK_TRACK_0_R+o], 0, sizeof(float) * nframes );
}
}
@ -493,16 +546,16 @@ void Jack::processFrames(int nframes)
}
if ( inputToSendEnable ) {
// post-mix-send amount: hence * inputToMixVol
// TODO input r (stereo send)
buffers.audio[Buffers::SEND][i] += inputL * inputToSendVol * inputToMixVol;
buffers.audio[Buffers::SEND_L][i] += inputL * inputToSendVol * inputToMixVol;
buffers.audio[Buffers::SEND_R][i] += inputR * inputToSendVol * inputToMixVol;
}
if ( inputToKeyEnable ) {
// TODO input r (stereo key)
buffers.audio[Buffers::SIDECHAIN_KEY][i] += inputL;
buffers.audio[Buffers::SIDECHAIN_KEY_R][i] += inputL;
buffers.audio[Buffers::SIDECHAIN_KEY_R][i] += inputR;
}
// TODO input r (stereo sidechain)
buffers.audio[Buffers::SIDECHAIN_SIGNAL][i] += inputL * inputToXSideVol;
buffers.audio[Buffers::SIDECHAIN_SIGNAL_L][i] += inputL * inputToXSideVol;
buffers.audio[Buffers::SIDECHAIN_SIGNAL_R][i] += inputR * inputToXSideVol;
//compute master volume lag;
if(fabs(masterVol-masterVolLag)>=fabs(masterVolDiff/10.0))
@ -512,9 +565,12 @@ void Jack::processFrames(int nframes)
buffers.audio[Buffers::JACK_MASTER_OUT_R][i] = (R + returnR*returnVol) * masterVolLag;
/// write SEND content to JACK port
buffers.audio[Buffers::JACK_SEND_OUT][i] = buffers.audio[Buffers::SEND][i];
buffers.audio[Buffers::JACK_SIDECHAIN_KEY][i] = buffers.audio[Buffers::SIDECHAIN_KEY][i];
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL][i] = buffers.audio[Buffers::SIDECHAIN_SIGNAL][i];
buffers.audio[Buffers::JACK_SEND_OUT_L][i] = buffers.audio[Buffers::SEND_L][i];
buffers.audio[Buffers::JACK_SEND_OUT_R][i] = buffers.audio[Buffers::SEND_R][i];
buffers.audio[Buffers::JACK_SIDECHAIN_KEY_L][i] = buffers.audio[Buffers::SIDECHAIN_KEY_L][i];
buffers.audio[Buffers::JACK_SIDECHAIN_KEY_R][i] = buffers.audio[Buffers::SIDECHAIN_KEY_R][i];
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL_L][i] = buffers.audio[Buffers::SIDECHAIN_SIGNAL_L][i];
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL_R][i] = buffers.audio[Buffers::SIDECHAIN_SIGNAL_R][i];
}
@ -553,20 +609,26 @@ void Jack::processFrames(int nframes)
/// update buffers by nframes
if(lastnframes+nframes<buffers.nframes) {
lastnframes=nframes;
buffers.audio[Buffers::MASTER_INPUT_L] = &buffers.audio[Buffers::MASTER_INPUT_L][nframes];
buffers.audio[Buffers::MASTER_INPUT_R] = &buffers.audio[Buffers::MASTER_INPUT_R][nframes];
buffers.audio[Buffers::MASTER_RETURN_L] = &buffers.audio[Buffers::MASTER_RETURN_L][nframes];
buffers.audio[Buffers::MASTER_RETURN_R] = &buffers.audio[Buffers::MASTER_RETURN_R][nframes];
buffers.audio[Buffers::HEADPHONES_OUT] = &buffers.audio[Buffers::HEADPHONES_OUT] [nframes];
buffers.audio[Buffers::MASTER_INPUT_L] = &buffers.audio[Buffers::MASTER_INPUT_L][nframes];
buffers.audio[Buffers::MASTER_INPUT_R] = &buffers.audio[Buffers::MASTER_INPUT_R][nframes];
buffers.audio[Buffers::MASTER_RETURN_L] = &buffers.audio[Buffers::MASTER_RETURN_L][nframes];
buffers.audio[Buffers::MASTER_RETURN_R] = &buffers.audio[Buffers::MASTER_RETURN_R][nframes];
buffers.audio[Buffers::HEADPHONES_OUT_L] = &buffers.audio[Buffers::HEADPHONES_OUT_L][nframes];
buffers.audio[Buffers::HEADPHONES_OUT_R] = &buffers.audio[Buffers::HEADPHONES_OUT_R][nframes];
buffers.audio[Buffers::JACK_SEND_OUT] = &buffers.audio[Buffers::JACK_SEND_OUT][nframes];
buffers.audio[Buffers::JACK_MASTER_OUT_L] = &buffers.audio[Buffers::JACK_MASTER_OUT_L][nframes];
buffers.audio[Buffers::JACK_MASTER_OUT_R] = &buffers.audio[Buffers::JACK_MASTER_OUT_R][nframes];
buffers.audio[Buffers::JACK_SIDECHAIN_KEY] = &buffers.audio[Buffers::JACK_SIDECHAIN_KEY][nframes];
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL]=&buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL][nframes];
buffers.audio[Buffers::JACK_SEND_OUT_L] = &buffers.audio[Buffers::JACK_SEND_OUT_L][nframes];
buffers.audio[Buffers::JACK_SEND_OUT_R] = &buffers.audio[Buffers::JACK_SEND_OUT_R][nframes];
buffers.audio[Buffers::JACK_MASTER_OUT_L] = &buffers.audio[Buffers::JACK_MASTER_OUT_L][nframes];
buffers.audio[Buffers::JACK_MASTER_OUT_R] = &buffers.audio[Buffers::JACK_MASTER_OUT_R][nframes];
buffers.audio[Buffers::JACK_SIDECHAIN_KEY_L] = &buffers.audio[Buffers::JACK_SIDECHAIN_KEY_L][nframes];
buffers.audio[Buffers::JACK_SIDECHAIN_KEY_R] = &buffers.audio[Buffers::JACK_SIDECHAIN_KEY_R][nframes];
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL_L]= &buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL_L][nframes];
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL_R]= &buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL_R][nframes];
if(gui->enablePerTrackOutput) {
for(int t=0; t<NTRACKS; t++) {
buffers.audio[Buffers::JACK_TRACK_0+t] = &buffers.audio[Buffers::JACK_TRACK_0+t][nframes];
int o = t*2;
buffers.audio[Buffers::JACK_TRACK_0_L+o] = &buffers.audio[Buffers::JACK_TRACK_0_L+o][nframes];
buffers.audio[Buffers::JACK_TRACK_0_L+o+1] = &buffers.audio[Buffers::JACK_TRACK_0_L+o+1][nframes];
}
}
} else
@ -577,16 +639,23 @@ void Jack::processFrames(int nframes)
void Jack::clearInternalBuffers(int nframes)
{
memset(buffers.audio[Buffers::SEND],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SIDECHAIN_KEY],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SIDECHAIN_SIGNAL],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SEND_L],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SEND_R],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SIDECHAIN_KEY_L],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SIDECHAIN_KEY_R],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SIDECHAIN_SIGNAL_L],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SIDECHAIN_SIGNAL_R],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::MASTER_OUT_L],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::MASTER_OUT_R],0,sizeof(float)*nframes);
for(int i=0; i<NTRACKS; i++) {
memset(buffers.audio[Buffers::TRACK_0 + i],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SEND_TRACK_0 + i],0,sizeof(float)*nframes);
int o = i*2;
memset(buffers.audio[Buffers::TRACK_0_L + o],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::TRACK_0_R + o],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SEND_TRACK_0_L + o],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SEND_TRACK_0_R + o],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::RETURN_TRACK_0 + i],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::RETURN_TRACK_0_L + o],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::RETURN_TRACK_0_R + o],0,sizeof(float)*nframes);
}
}

14
src/jack.hxx
View File

@ -180,15 +180,19 @@ private:
jack_port_t* masterReturnL;
jack_port_t* masterReturnR;
jack_port_t* headphonesPort;
jack_port_t* headphonesPortL;
jack_port_t* headphonesPortR;
jack_port_t* sidechainKeyOutput;
jack_port_t* sidechainSignalOutput;
jack_port_t* sendOutput;
jack_port_t* sidechainKeyOutputL;
jack_port_t* sidechainKeyOutputR;
jack_port_t* sidechainSignalOutputL;
jack_port_t* sidechainSignalOutputR;
jack_port_t* sendOutputL;
jack_port_t* sendOutputR;
jack_port_t* masterMidiInput;
jack_port_t* trackJackOutputPorts[NTRACKS];
jack_port_t* trackJackOutputPorts[NTRACKS*2];
// JACK callback
int process (jack_nframes_t);

54
src/jacksendreturn.cxx
View File

@ -7,10 +7,14 @@ JackSendReturn::JackSendReturn(int trackid, AudioProcessor *prev, jack_client_t
:m_trackid(trackid), m_previousProcessor(prev), m_sendvol(1.0f)
{
char name[50];
sprintf(name, "Send_track_%d\n",trackid);
m_sendport=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsOutput,0);
sprintf(name, "Return_track_%d\n",trackid);
m_returnport=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsInput,0);
sprintf(name, "Send_track_%d_l\n",trackid);
m_sendport_l=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsOutput,0);
sprintf(name, "Send_track_%d_r\n",trackid);
m_sendport_r=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsOutput,0);
sprintf(name, "Return_track_%d_l\n",trackid);
m_returnport_l=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsInput,0);
sprintf(name, "Return_track_%d_r\n",trackid);
m_returnport_r=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsInput,0);
m_active=false;
m_counter=0;
}
@ -19,24 +23,33 @@ void JackSendReturn::process(unsigned int nframes, Buffers *buffers)
{
//Reset send buffer
int offset=m_counter%(buffers->nframes);
float* sendtrack=&(buffers->audio[Buffers::SEND_TRACK_0+m_trackid][0]);
float* sendtrackL=&(buffers->audio[Buffers::SEND_TRACK_0_L+m_trackid][0]);
float* sendtrackR=&(buffers->audio[Buffers::SEND_TRACK_0_R+m_trackid][0]);
float* rettrack=&(buffers->audio[Buffers::RETURN_TRACK_0+m_trackid][0]);
float* rettrackL=&(buffers->audio[Buffers::RETURN_TRACK_0_L+m_trackid][0]);
float* rettrackR=&(buffers->audio[Buffers::RETURN_TRACK_0_R+m_trackid][0]);
memset(sendtrack,0,nframes*sizeof(float));
memset(sendtrackL,0,nframes*sizeof(float));
memset(sendtrackR,0,nframes*sizeof(float));
//Process previous AudioProcessor
m_previousProcessor->process(nframes,buffers);
float* send=(float*)jack_port_get_buffer(m_sendport,(jack_nframes_t)(buffers->nframes));
float* ret=(float*)jack_port_get_buffer(m_returnport,(jack_nframes_t)(buffers->nframes));
float* sendL=(float*)jack_port_get_buffer(m_sendport_l,(jack_nframes_t)(buffers->nframes));
float* sendR=(float*)jack_port_get_buffer(m_sendport_r,(jack_nframes_t)(buffers->nframes));
float* retL=(float*)jack_port_get_buffer(m_returnport_l,(jack_nframes_t)(buffers->nframes));
float* retR=(float*)jack_port_get_buffer(m_returnport_r,(jack_nframes_t)(buffers->nframes));
if(offset) {
send+=offset;
ret+=offset;
sendL+=offset;
sendR+=offset;
retL+=offset;
retR+=offset;
}
for(int i=0; i<nframes; i++)
send[i]=m_sendvol*sendtrack[i];
for(int i=0; i<nframes; i++) {
sendL[i]=m_sendvol*sendtrackL[i];
sendR[i]=m_sendvol*sendtrackR[i];
}
// if(nframes!=buffers->nframes)
// {
// cout<<send<<endl;
@ -45,11 +58,16 @@ void JackSendReturn::process(unsigned int nframes, Buffers *buffers)
if(offset)
assert(offset+nframes==buffers->nframes);
if(m_active)
memcpy(rettrack,ret,nframes*sizeof(float));
else
memcpy(rettrack,
sendtrack,nframes*sizeof(float));
if(m_active) {
memcpy(rettrackL,retL,nframes*sizeof(float));
memcpy(rettrackR,retR,nframes*sizeof(float));
}
else {
memcpy(rettrackL,
sendtrackL,nframes*sizeof(float));
memcpy(rettrackR,
sendtrackR,nframes*sizeof(float));
}
m_counter+=nframes;
}

6
src/jacksendreturn.hxx
View File

@ -45,8 +45,10 @@ public:
private:
bool m_active;
float m_sendvol;
jack_port_t* m_sendport;
jack_port_t* m_returnport;
jack_port_t* m_sendport_l;
jack_port_t* m_sendport_r;
jack_port_t* m_returnport_l;
jack_port_t* m_returnport_r;
int m_trackid;
AudioProcessor* m_previousProcessor;
int m_counter;

20
src/looper.cxx
View File

@ -131,8 +131,8 @@ void Looper::process(unsigned int nframes, Buffers* buffers)
playSpeed = float(actualFrames) / targetFrames;
}
// TODO stereo sends
float* out = buffers->audio[Buffers::SEND_TRACK_0 + track];
float* outL = buffers->audio[Buffers::SEND_TRACK_0_L + track];
float* outR = buffers->audio[Buffers::SEND_TRACK_0_R + track];
for(unsigned int i = 0; i < nframes; i++ ) {
// REFACTOR into system that is better than per sample function calls
@ -146,14 +146,14 @@ void Looper::process(unsigned int nframes, Buffers* buffers)
// write the pitch-shifted signal to the track buffer
//FIXME: pitchShift adds delay even for playSpeed = 1.0!!
//we should use something better (e.g librubberband)
if(playSpeed!=1.0f)
pitchShift( 1, &tmpL, &out[i] );
// TODO stereo sends
//pitchShift( 1, tmpR, &out[i] );
else
// TODO stereo sends
out[i]+=tmpL;
//outR[i]+=tmpR;
if(playSpeed!=1.0f) {
pitchShift( 1, &tmpL, &outL[i] );
pitchShift( 1, &tmpR, &outR[i] );
}
else {
outL[i]+=tmpL;
outR[i]+=tmpR;
}
}
//printf("Looper %i playing(), speed = %f\n", track, playSpeed );

6
src/metronome.cxx
View File

@ -100,7 +100,8 @@ void Metronome::process(int nframes, Buffers* buffers)
if ( not active )
return;
float* out = buffers->audio[Buffers::HEADPHONES_OUT];
float* outL = buffers->audio[Buffers::HEADPHONES_OUT_L];
float* outR = buffers->audio[Buffers::HEADPHONES_OUT_R];
float* sample = &beatSample[0];
if( playBar ) {
@ -109,7 +110,8 @@ void Metronome::process(int nframes, Buffers* buffers)
for(int i = 0; i < nframes; i++) {
if ( playPoint < endPoint ) {
out[i] += sample[playPoint] * vol;
outL[i] += sample[playPoint] * vol;
outR[i] += sample[playPoint] * vol;
playPoint++;
}
}

51
src/trackoutput.cxx
View File

@ -114,14 +114,16 @@ void TrackOutput::process(unsigned int nframes, Buffers* buffers)
if(fabs(_toMaster-_toMasterLag)>=fabs(_toMasterDiff/100.0))
_toMasterLag+=_toMasterDiff/10.0;
// get & zero track buffer
float* trackBuffer = buffers->audio[Buffers::RETURN_TRACK_0 + track];
memset( trackBuffer, 0, sizeof(float)*nframes );
float* trackBufferL = buffers->audio[Buffers::RETURN_TRACK_0_L + track];
float* trackBufferR = buffers->audio[Buffers::RETURN_TRACK_0_R + track];
memset( trackBufferL, 0, sizeof(float)*nframes );
memset( trackBufferR, 0, sizeof(float)*nframes );
// call process() up the chain
previousInChain->process( nframes, buffers );
// run the meter
dbMeter->process( nframes, trackBuffer, trackBuffer );
dbMeter->process( nframes, trackBufferL, trackBufferR );
if (uiUpdateCounter > uiUpdateConstant ) {
float l = dbMeter->getLeftDB() * _toMasterLag;
@ -134,15 +136,19 @@ void TrackOutput::process(unsigned int nframes, Buffers* buffers)
uiUpdateCounter += nframes;
// copy audio data into reverb / sidechain / master buffers
float* reverb = buffers->audio[Buffers::SEND];
float* sidechain = buffers->audio[Buffers::SIDECHAIN_KEY];
float* postSidechain = buffers->audio[Buffers::SIDECHAIN_SIGNAL];
float* reverbL = buffers->audio[Buffers::SEND_L];
float* reverbR = buffers->audio[Buffers::SEND_R];
float* sidechainL = buffers->audio[Buffers::SIDECHAIN_KEY_L];
float* sidechainR = buffers->audio[Buffers::SIDECHAIN_KEY_R];
float* postSidechainL = buffers->audio[Buffers::SIDECHAIN_SIGNAL_L];
float* postSidechainR = buffers->audio[Buffers::SIDECHAIN_SIGNAL_R];
float* masterL = buffers->audio[Buffers::MASTER_OUT_L];
float* masterR = buffers->audio[Buffers::MASTER_OUT_R];
float* jackoutput = buffers->audio[Buffers::JACK_TRACK_0+track];
float* jackoutputL = buffers->audio[Buffers::JACK_TRACK_0_L+track];
float* jackoutputR = buffers->audio[Buffers::JACK_TRACK_0_R+track];
/* Trial + Error leads to this algo - its cheap and cheerful */
float p = ((_toMasterPan + 1.0f) * 0.5f) * (M_PI * 0.5);
@ -153,22 +159,31 @@ void TrackOutput::process(unsigned int nframes, Buffers* buffers)
for(unsigned int i = 0; i < nframes; i++) {
// * master for "post-fader" sends
float tmp = trackBuffer[i];
float tmpL = trackBufferL[i];
float tmpR = trackBufferR[i];
// post-sidechain *moves* signal between "before/after" ducking, not add!
masterL[i] += tmp * _toMasterLag * (1-_toPostSidechain) * pan_l;
masterR[i] += tmp * _toMasterLag * (1-_toPostSidechain) * pan_r;
if(jackoutput)
jackoutput[i] = tmp * _toMasterLag * (1-_toPostSidechain);
if ( _toPostfaderActive )
reverb[i] += tmp * _toReverb * _toMasterLag;
masterL[i] += tmpL * _toMasterLag * (1-_toPostSidechain) * pan_l;
masterR[i] += tmpR * _toMasterLag * (1-_toPostSidechain) * pan_r;
if(jackoutputL)
jackoutputL[i] = tmpL * _toMasterLag * (1-_toPostSidechain);
if(jackoutputR)
jackoutputR[i] = tmpR * _toMasterLag * (1-_toPostSidechain);
if ( _toPostfaderActive ) {
reverbL[i] += tmpL * _toReverb * _toMasterLag;
reverbR[i] += tmpR * _toReverb * _toMasterLag;
}
if ( _toXSideActive )
postSidechain[i] += tmp * _toPostSidechain * _toMasterLag;
if ( _toXSideActive ) {
postSidechainL[i] += tmpL * _toPostSidechain * _toMasterLag;
postSidechainR[i] += tmpR * _toPostSidechain * _toMasterLag;
}
// turning down an element in the mix should *NOT* influence sidechaining
if ( _toKeyActive )
sidechain[i] += tmp;
if ( _toKeyActive ) {
sidechainL[i] += tmpL;
sidechainR[i] += tmpR;
}
}
}