hiro/openAV-Luppp
1
0
Fork 0
mirror of https://github.com/vale981/openAV-Luppp synced 2025-03-05 09:01:39 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use stereo signal for all channels

Browse source
This commit is contained in:
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_L,
MASTER_OUT_R, MASTER_OUT_R,
JACK_SEND_OUT, JACK_SEND_OUT_L,
JACK_SEND_OUT_R,
JACK_MASTER_OUT_L, JACK_MASTER_OUT_L,
JACK_MASTER_OUT_R, JACK_MASTER_OUT_R,
JACK_SIDECHAIN_KEY, JACK_SIDECHAIN_KEY_L,
JACK_SIDECHAIN_SIGNAL, JACK_SIDECHAIN_KEY_R,
JACK_SIDECHAIN_SIGNAL_L,
JACK_SIDECHAIN_SIGNAL_R,
SEND, SEND_L,
SIDECHAIN_KEY, SEND_R,
SIDECHAIN_SIGNAL, SIDECHAIN_KEY_L,
SIDECHAIN_KEY_R,
SIDECHAIN_SIGNAL_L,
SIDECHAIN_SIGNAL_R,
MASTER_RETURN_L, MASTER_RETURN_L,
MASTER_RETURN_R, MASTER_RETURN_R,
HEADPHONES_OUT, HEADPHONES_OUT_L,
HEADPHONES_OUT_R,
// MIDI // MIDI
MASTER_MIDI_INPUT, MASTER_MIDI_INPUT,
@ -55,40 +62,72 @@ public:
// track buffers: they are the "working" buffers per track: // track buffers: they are the "working" buffers per track:
// the end result is mixed into the master output, while each // the end result is mixed into the master output, while each
// stage along the way the amplitude etc can be analysed // stage along the way the amplitude etc can be analysed
TRACK_0, TRACK_0_L,
TRACK_1, TRACK_0_R,
TRACK_2, TRACK_1_L,
TRACK_3, TRACK_1_R,
TRACK_4, TRACK_2_L,
TRACK_5, TRACK_2_R,
TRACK_6, TRACK_3_L,
TRACK_7, 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 //Per track sends/returns
SEND_TRACK_0, SEND_TRACK_0_L,
SEND_TRACK_1, SEND_TRACK_0_R,
SEND_TRACK_2, SEND_TRACK_1_L,
SEND_TRACK_3, SEND_TRACK_1_R,
SEND_TRACK_4, SEND_TRACK_2_L,
SEND_TRACK_5, SEND_TRACK_2_R,
SEND_TRACK_6, SEND_TRACK_3_L,
SEND_TRACK_7, SEND_TRACK_3_R,
RETURN_TRACK_0, SEND_TRACK_4_L,
RETURN_TRACK_1, SEND_TRACK_4_R,
RETURN_TRACK_2, SEND_TRACK_5_L,
RETURN_TRACK_3, SEND_TRACK_5_R,
RETURN_TRACK_4, SEND_TRACK_6_L,
RETURN_TRACK_5, SEND_TRACK_6_R,
RETURN_TRACK_6, SEND_TRACK_7_L,
RETURN_TRACK_7, 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_0_L,
JACK_TRACK_1, JACK_TRACK_0_R,
JACK_TRACK_2, JACK_TRACK_1_L,
JACK_TRACK_3, JACK_TRACK_1_R,
JACK_TRACK_4, JACK_TRACK_2_L,
JACK_TRACK_5, JACK_TRACK_2_R,
JACK_TRACK_6, JACK_TRACK_3_L,
JACK_TRACK_7, 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, BUFFER_COUNT,

223
src/jack.cxx
View file

@ -145,29 +145,53 @@ Jack::Jack( std::string name ) :
JackPortIsOutput, JackPortIsOutput,
0 ); 0 );
headphonesPort = jack_port_register( client, headphonesPortL = jack_port_register( client,
"headphone_out", "headphone_out_l",
JACK_DEFAULT_AUDIO_TYPE, JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput, JackPortIsOutput,
0 ); 0 );
sendOutput = jack_port_register( client, headphonesPortR = jack_port_register( client,
"send_out", "headphone_out_r",
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput,
0 );
sendOutputL = jack_port_register( client,
"send_out_l",
JACK_DEFAULT_AUDIO_TYPE, JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput, JackPortIsOutput,
0 ); 0 );
sidechainKeyOutput= jack_port_register( client, sendOutputR = jack_port_register( client,
"sidechain_key", "send_out_r",
JACK_DEFAULT_AUDIO_TYPE, JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput, JackPortIsOutput,
0 ); 0 );
sidechainSignalOutput= jack_port_register( client, sidechainKeyOutputL = jack_port_register( client,
"sidechain_signal", "sidechain_key_l",
JACK_DEFAULT_AUDIO_TYPE, JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput, JackPortIsOutput,
0 ); 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, masterMidiInput = jack_port_register( client,
@ -188,9 +212,12 @@ Jack::Jack( std::string name ) :
inputToXSideVol = 0.f; inputToXSideVol = 0.f;
/// prepare internal buffers /// prepare internal buffers
buffers.audio[Buffers::SEND] = new float[ buffers.nframes ]; buffers.audio[Buffers::SEND_L] = new float[ buffers.nframes ];
buffers.audio[Buffers::SIDECHAIN_KEY] = new float[ buffers.nframes ]; buffers.audio[Buffers::SEND_R] = new float[ buffers.nframes ];
buffers.audio[Buffers::SIDECHAIN_SIGNAL]=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_L] = new float[ buffers.nframes ];
buffers.audio[Buffers::MASTER_OUT_R] = 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)); tracksendreturns.push_back(new JackSendReturn(i,loopers.back(),client));
trackOutputs.push_back( new TrackOutput(i, tracksendreturns.back() ) ); trackOutputs.push_back( new TrackOutput(i, tracksendreturns.back() ) );
buffers.audio[Buffers::TRACK_0 + i] = new float[ buffers.nframes ]; int o = i*2;
buffers.audio[Buffers::SEND_TRACK_0+i]=new float[buffers.nframes]; buffers.audio[Buffers::TRACK_0_L + o] = new float[ buffers.nframes ];
buffers.audio[Buffers::RETURN_TRACK_0+i]=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() ); timeManager->registerObserver( loopers.back() );
if(gui->enablePerTrackOutput) { if(gui->enablePerTrackOutput) {
char name[50]; char name[50];
sprintf(name,"track_%d\n",i); sprintf(name,"track_%d_l",i);
trackJackOutputPorts[i]=jack_port_register( client, trackJackOutputPorts[o]=jack_port_register( client,
name, name,
JACK_DEFAULT_AUDIO_TYPE, JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput, JackPortIsOutput,
0 ); 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 inputMeter;
delete masterMeter; delete masterMeter;
for(int i = 0; i < NTRACKS; i++) { for(int i = 0; i < NTRACKS; i++) {
delete [] buffers.audio[Buffers::TRACK_0+i]; int o = i*2;
delete [] buffers.audio[Buffers::SEND_TRACK_0+i]; delete [] buffers.audio[Buffers::TRACK_0_L+o];
delete [] buffers.audio[Buffers::RETURN_TRACK_0+i]; 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 tracksendreturns[i];
delete loopers[i]; delete loopers[i];
delete trackOutputs[i]; delete trackOutputs[i];
@ -309,7 +350,7 @@ void Jack::quit()
TrackOutput* Jack::getTrackOutput(int t) TrackOutput* Jack::getTrackOutput(int t)
{ {
if ( t >= 0 && t < NTRACKS ) if ( t >= 0 && t < NTRACKS*2 )
return trackOutputs.at(t); return trackOutputs.at(t);
#ifdef DEBUG_TRACKS #ifdef DEBUG_TRACKS
else { else {
@ -322,7 +363,7 @@ TrackOutput* Jack::getTrackOutput(int t)
JackSendReturn* Jack::getJackSendReturn(int t) JackSendReturn* Jack::getJackSendReturn(int t)
{ {
if ( t >= 0 && t < NTRACKS ) if ( t >= 0 && t < NTRACKS*2 )
return tracksendreturns.at(t); return tracksendreturns.at(t);
#ifdef DEBUG_TRACKS #ifdef DEBUG_TRACKS
else { else {
@ -336,7 +377,7 @@ JackSendReturn* Jack::getJackSendReturn(int t)
Looper* Jack::getLooper(int t) Looper* Jack::getLooper(int t)
{ {
if ( t >= 0 && t < NTRACKS ) if ( t >= 0 && t < NTRACKS*2 )
return loopers.at(t); return loopers.at(t);
#ifdef DEBUG_TRACKS #ifdef DEBUG_TRACKS
else { else {
@ -373,21 +414,27 @@ void Jack::unregisterMidiIO( MidiIO* mo )
int Jack::process (jack_nframes_t nframes) int Jack::process (jack_nframes_t nframes)
{ {
/// get buffers /// get buffers
buffers.audio[Buffers::MASTER_INPUT_L] = (float*)jack_port_get_buffer( masterInputL , 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_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_L] = (float*)jack_port_get_buffer( masterReturnL, nframes );
buffers.audio[Buffers::MASTER_RETURN_R] = (float*)jack_port_get_buffer( masterReturnR , 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::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_SEND_OUT_L] = (float*)jack_port_get_buffer( sendOutputL, nframes );
buffers.audio[Buffers::JACK_MASTER_OUT_L] = (float*)jack_port_get_buffer( masterOutputL , nframes ); buffers.audio[Buffers::JACK_SEND_OUT_R] = (float*)jack_port_get_buffer( sendOutputR, nframes );
buffers.audio[Buffers::JACK_MASTER_OUT_R] = (float*)jack_port_get_buffer( masterOutputR , nframes ); buffers.audio[Buffers::JACK_MASTER_OUT_L] = (float*)jack_port_get_buffer( masterOutputL, nframes );
buffers.audio[Buffers::JACK_SIDECHAIN_KEY] = (float*)jack_port_get_buffer(sidechainKeyOutput,nframes); buffers.audio[Buffers::JACK_MASTER_OUT_R] = (float*)jack_port_get_buffer( masterOutputR, nframes );
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL]=(float*)jack_port_get_buffer(sidechainSignalOutput,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) { if(gui->enablePerTrackOutput) {
for(int t=0; t<NTRACKS; t++) for(int t=0; t<NTRACKS; t++) {
buffers.audio[Buffers::JACK_TRACK_0+t] = (float*)jack_port_get_buffer( trackJackOutputPorts[t] , nframes ); 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::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_L] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::MASTER_OUT_R] , 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::HEADPHONES_OUT_L] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SEND] , 0, sizeof(float) * nframes ); memset( buffers.audio[Buffers::HEADPHONES_OUT_R] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SIDECHAIN_KEY] , 0, sizeof(float) * nframes ); memset( buffers.audio[Buffers::SEND_L] , 0, sizeof(float) * nframes );
memset( buffers.audio[Buffers::SIDECHAIN_SIGNAL] , 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) { if(gui->enablePerTrackOutput) {
for(int t=0; t<NTRACKS; t++) for(int t=0; t<NTRACKS; t++) {
memset( buffers.audio[Buffers::JACK_TRACK_0+t] , 0, sizeof(float) * nframes ); 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 ) { if ( inputToSendEnable ) {
// post-mix-send amount: hence * inputToMixVol // post-mix-send amount: hence * inputToMixVol
// TODO input r (stereo send) buffers.audio[Buffers::SEND_L][i] += inputL * inputToSendVol * inputToMixVol;
buffers.audio[Buffers::SEND][i] += inputL * inputToSendVol * inputToMixVol; buffers.audio[Buffers::SEND_R][i] += inputR * inputToSendVol * inputToMixVol;
} }
if ( inputToKeyEnable ) { if ( inputToKeyEnable ) {
// TODO input r (stereo key) buffers.audio[Buffers::SIDECHAIN_KEY_R][i] += inputL;
buffers.audio[Buffers::SIDECHAIN_KEY][i] += inputL; buffers.audio[Buffers::SIDECHAIN_KEY_R][i] += inputR;
} }
// TODO input r (stereo sidechain) buffers.audio[Buffers::SIDECHAIN_SIGNAL_L][i] += inputL * inputToXSideVol;
buffers.audio[Buffers::SIDECHAIN_SIGNAL][i] += inputL * inputToXSideVol; buffers.audio[Buffers::SIDECHAIN_SIGNAL_R][i] += inputR * inputToXSideVol;
//compute master volume lag; //compute master volume lag;
if(fabs(masterVol-masterVolLag)>=fabs(masterVolDiff/10.0)) 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; buffers.audio[Buffers::JACK_MASTER_OUT_R][i] = (R + returnR*returnVol) * masterVolLag;
/// write SEND content to JACK port /// write SEND content to JACK port
buffers.audio[Buffers::JACK_SEND_OUT][i] = buffers.audio[Buffers::SEND][i]; buffers.audio[Buffers::JACK_SEND_OUT_L][i] = buffers.audio[Buffers::SEND_L][i];
buffers.audio[Buffers::JACK_SIDECHAIN_KEY][i] = buffers.audio[Buffers::SIDECHAIN_KEY][i]; buffers.audio[Buffers::JACK_SEND_OUT_R][i] = buffers.audio[Buffers::SEND_R][i];
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL][i] = buffers.audio[Buffers::SIDECHAIN_SIGNAL][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 /// update buffers by nframes
if(lastnframes+nframes<buffers.nframes) { if(lastnframes+nframes<buffers.nframes) {
lastnframes=nframes; lastnframes=nframes;
buffers.audio[Buffers::MASTER_INPUT_L] = &buffers.audio[Buffers::MASTER_INPUT_L][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_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_L] = &buffers.audio[Buffers::MASTER_RETURN_L][nframes];
buffers.audio[Buffers::MASTER_RETURN_R] = &buffers.audio[Buffers::MASTER_RETURN_R][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::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_SEND_OUT_L] = &buffers.audio[Buffers::JACK_SEND_OUT_L][nframes];
buffers.audio[Buffers::JACK_MASTER_OUT_L] = &buffers.audio[Buffers::JACK_MASTER_OUT_L][nframes]; buffers.audio[Buffers::JACK_SEND_OUT_R] = &buffers.audio[Buffers::JACK_SEND_OUT_R][nframes];
buffers.audio[Buffers::JACK_MASTER_OUT_R] = &buffers.audio[Buffers::JACK_MASTER_OUT_R][nframes]; buffers.audio[Buffers::JACK_MASTER_OUT_L] = &buffers.audio[Buffers::JACK_MASTER_OUT_L][nframes];
buffers.audio[Buffers::JACK_SIDECHAIN_KEY] = &buffers.audio[Buffers::JACK_SIDECHAIN_KEY][nframes]; buffers.audio[Buffers::JACK_MASTER_OUT_R] = &buffers.audio[Buffers::JACK_MASTER_OUT_R][nframes];
buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL]=&buffers.audio[Buffers::JACK_SIDECHAIN_SIGNAL][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) { if(gui->enablePerTrackOutput) {
for(int t=0; t<NTRACKS; t++) { 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 } else
@ -577,16 +639,23 @@ void Jack::processFrames(int nframes)
void Jack::clearInternalBuffers(int nframes) void Jack::clearInternalBuffers(int nframes)
{ {
memset(buffers.audio[Buffers::SEND],0,sizeof(float)*nframes); memset(buffers.audio[Buffers::SEND_L],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SIDECHAIN_KEY],0,sizeof(float)*nframes); memset(buffers.audio[Buffers::SEND_R],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::SIDECHAIN_SIGNAL],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_L],0,sizeof(float)*nframes);
memset(buffers.audio[Buffers::MASTER_OUT_R],0,sizeof(float)*nframes); memset(buffers.audio[Buffers::MASTER_OUT_R],0,sizeof(float)*nframes);
for(int i=0; i<NTRACKS; i++) { for(int i=0; i<NTRACKS; i++) {
memset(buffers.audio[Buffers::TRACK_0 + i],0,sizeof(float)*nframes); int o = i*2;
memset(buffers.audio[Buffers::SEND_TRACK_0 + i],0,sizeof(float)*nframes); 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* masterReturnL;
jack_port_t* masterReturnR; jack_port_t* masterReturnR;
jack_port_t* headphonesPort; jack_port_t* headphonesPortL;
jack_port_t* headphonesPortR;
jack_port_t* sidechainKeyOutput; jack_port_t* sidechainKeyOutputL;
jack_port_t* sidechainSignalOutput; jack_port_t* sidechainKeyOutputR;
jack_port_t* sendOutput; jack_port_t* sidechainSignalOutputL;
jack_port_t* sidechainSignalOutputR;
jack_port_t* sendOutputL;
jack_port_t* sendOutputR;
jack_port_t* masterMidiInput; jack_port_t* masterMidiInput;
jack_port_t* trackJackOutputPorts[NTRACKS]; jack_port_t* trackJackOutputPorts[NTRACKS*2];
// JACK callback // JACK callback
int process (jack_nframes_t); 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) :m_trackid(trackid), m_previousProcessor(prev), m_sendvol(1.0f)
{ {
char name[50]; char name[50];
sprintf(name, "Send_track_%d\n",trackid); sprintf(name, "Send_track_%d_l\n",trackid);
m_sendport=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsOutput,0); m_sendport_l=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsOutput,0);
sprintf(name, "Return_track_%d\n",trackid); sprintf(name, "Send_track_%d_r\n",trackid);
m_returnport=jack_port_register(client,name,JACK_DEFAULT_AUDIO_TYPE,JackPortIsInput,0); 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_active=false;
m_counter=0; m_counter=0;
} }
@ -19,24 +23,33 @@ void JackSendReturn::process(unsigned int nframes, Buffers *buffers)
{ {
//Reset send buffer //Reset send buffer
int offset=m_counter%(buffers->nframes); 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 //Process previous AudioProcessor
m_previousProcessor->process(nframes,buffers); m_previousProcessor->process(nframes,buffers);
float* send=(float*)jack_port_get_buffer(m_sendport,(jack_nframes_t)(buffers->nframes)); float* sendL=(float*)jack_port_get_buffer(m_sendport_l,(jack_nframes_t)(buffers->nframes));
float* ret=(float*)jack_port_get_buffer(m_returnport,(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) { if(offset) {
send+=offset; sendL+=offset;
ret+=offset; sendR+=offset;
retL+=offset;
retR+=offset;
} }
for(int i=0; i<nframes; i++) for(int i=0; i<nframes; i++) {
send[i]=m_sendvol*sendtrack[i]; sendL[i]=m_sendvol*sendtrackL[i];
sendR[i]=m_sendvol*sendtrackR[i];
}
// if(nframes!=buffers->nframes) // if(nframes!=buffers->nframes)
// { // {
// cout<<send<<endl; // cout<<send<<endl;
@ -45,11 +58,16 @@ void JackSendReturn::process(unsigned int nframes, Buffers *buffers)
if(offset) if(offset)
assert(offset+nframes==buffers->nframes); assert(offset+nframes==buffers->nframes);
if(m_active) if(m_active) {
memcpy(rettrack,ret,nframes*sizeof(float)); memcpy(rettrackL,retL,nframes*sizeof(float));
else memcpy(rettrackR,retR,nframes*sizeof(float));
memcpy(rettrack, }
sendtrack,nframes*sizeof(float)); else {
memcpy(rettrackL,
sendtrackL,nframes*sizeof(float));
memcpy(rettrackR,
sendtrackR,nframes*sizeof(float));
}
m_counter+=nframes; m_counter+=nframes;
} }

6
src/jacksendreturn.hxx
View file

@ -45,8 +45,10 @@ public:
private: private:
bool m_active; bool m_active;
float m_sendvol; float m_sendvol;
jack_port_t* m_sendport; jack_port_t* m_sendport_l;
jack_port_t* m_returnport; jack_port_t* m_sendport_r;
jack_port_t* m_returnport_l;
jack_port_t* m_returnport_r;
int m_trackid; int m_trackid;
AudioProcessor* m_previousProcessor; AudioProcessor* m_previousProcessor;
int m_counter; 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; playSpeed = float(actualFrames) / targetFrames;
} }
// TODO stereo sends float* outL = buffers->audio[Buffers::SEND_TRACK_0_L + track];
float* out = buffers->audio[Buffers::SEND_TRACK_0 + track]; float* outR = buffers->audio[Buffers::SEND_TRACK_0_R + track];
for(unsigned int i = 0; i < nframes; i++ ) { for(unsigned int i = 0; i < nframes; i++ ) {
// REFACTOR into system that is better than per sample function calls // 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 // write the pitch-shifted signal to the track buffer
//FIXME: pitchShift adds delay even for playSpeed = 1.0!! //FIXME: pitchShift adds delay even for playSpeed = 1.0!!
//we should use something better (e.g librubberband) //we should use something better (e.g librubberband)
if(playSpeed!=1.0f) if(playSpeed!=1.0f) {
pitchShift( 1, &tmpL, &out[i] ); pitchShift( 1, &tmpL, &outL[i] );
// TODO stereo sends pitchShift( 1, &tmpR, &outR[i] );
//pitchShift( 1, tmpR, &out[i] ); }
else else {
// TODO stereo sends outL[i]+=tmpL;
out[i]+=tmpL; outR[i]+=tmpR;
//outR[i]+=tmpR; }
} }
//printf("Looper %i playing(), speed = %f\n", track, playSpeed ); //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 ) if ( not active )
return; 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]; float* sample = &beatSample[0];
if( playBar ) { if( playBar ) {
@ -109,7 +110,8 @@ void Metronome::process(int nframes, Buffers* buffers)
for(int i = 0; i < nframes; i++) { for(int i = 0; i < nframes; i++) {
if ( playPoint < endPoint ) { if ( playPoint < endPoint ) {
out[i] += sample[playPoint] * vol; outL[i] += sample[playPoint] * vol;
outR[i] += sample[playPoint] * vol;
playPoint++; 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)) if(fabs(_toMaster-_toMasterLag)>=fabs(_toMasterDiff/100.0))
_toMasterLag+=_toMasterDiff/10.0; _toMasterLag+=_toMasterDiff/10.0;
// get & zero track buffer // get & zero track buffer
float* trackBuffer = buffers->audio[Buffers::RETURN_TRACK_0 + track]; float* trackBufferL = buffers->audio[Buffers::RETURN_TRACK_0_L + track];
memset( trackBuffer, 0, sizeof(float)*nframes ); 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 // call process() up the chain
previousInChain->process( nframes, buffers ); previousInChain->process( nframes, buffers );
// run the meter // run the meter
dbMeter->process( nframes, trackBuffer, trackBuffer ); dbMeter->process( nframes, trackBufferL, trackBufferR );
if (uiUpdateCounter > uiUpdateConstant ) { if (uiUpdateCounter > uiUpdateConstant ) {
float l = dbMeter->getLeftDB() * _toMasterLag; float l = dbMeter->getLeftDB() * _toMasterLag;
@ -134,15 +136,19 @@ void TrackOutput::process(unsigned int nframes, Buffers* buffers)
uiUpdateCounter += nframes; uiUpdateCounter += nframes;
// copy audio data into reverb / sidechain / master buffers // copy audio data into reverb / sidechain / master buffers
float* reverb = buffers->audio[Buffers::SEND]; float* reverbL = buffers->audio[Buffers::SEND_L];
float* sidechain = buffers->audio[Buffers::SIDECHAIN_KEY]; float* reverbR = buffers->audio[Buffers::SEND_R];
float* postSidechain = buffers->audio[Buffers::SIDECHAIN_SIGNAL]; 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* masterL = buffers->audio[Buffers::MASTER_OUT_L];
float* masterR = buffers->audio[Buffers::MASTER_OUT_R]; 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 */ /* Trial + Error leads to this algo - its cheap and cheerful */
float p = ((_toMasterPan + 1.0f) * 0.5f) * (M_PI * 0.5); 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++) { for(unsigned int i = 0; i < nframes; i++) {
// * master for "post-fader" sends // * 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! // post-sidechain *moves* signal between "before/after" ducking, not add!
masterL[i] += tmp * _toMasterLag * (1-_toPostSidechain) * pan_l; masterL[i] += tmpL * _toMasterLag * (1-_toPostSidechain) * pan_l;
masterR[i] += tmp * _toMasterLag * (1-_toPostSidechain) * pan_r; masterR[i] += tmpR * _toMasterLag * (1-_toPostSidechain) * pan_r;
if(jackoutput) if(jackoutputL)
jackoutput[i] = tmp * _toMasterLag * (1-_toPostSidechain); jackoutputL[i] = tmpL * _toMasterLag * (1-_toPostSidechain);
if ( _toPostfaderActive ) if(jackoutputR)
reverb[i] += tmp * _toReverb * _toMasterLag; jackoutputR[i] = tmpR * _toMasterLag * (1-_toPostSidechain);
if ( _toPostfaderActive ) {
reverbL[i] += tmpL * _toReverb * _toMasterLag;
reverbR[i] += tmpR * _toReverb * _toMasterLag;
}
if ( _toXSideActive ) if ( _toXSideActive ) {
postSidechain[i] += tmp * _toPostSidechain * _toMasterLag; postSidechainL[i] += tmpL * _toPostSidechain * _toMasterLag;
postSidechainR[i] += tmpR * _toPostSidechain * _toMasterLag;
}
// turning down an element in the mix should *NOT* influence sidechaining // turning down an element in the mix should *NOT* influence sidechaining
if ( _toKeyActive ) if ( _toKeyActive ) {
sidechain[i] += tmp; sidechainL[i] += tmpL;
sidechainR[i] += tmpR;
}
} }
} }