trunk/src/qsamplerFxSend.cpp

// qsamplerFxSend.cpp
//
/****************************************************************************
   Copyright (C) 2004-2019, rncbc aka Rui Nuno Capela. All rights reserved.
   Copyright (C) 2008, Christian Schoenebeck

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   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 for more details.

   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*****************************************************************************/

#include "qsamplerAbout.h"
#include "qsamplerFxSend.h"
#include "qsamplerUtilities.h"
#include "qsamplerOptions.h"
#include "qsamplerMainForm.h"

namespace QSampler {

// marks FxSend objects which don't exist on sampler side yet
#define NEW_FX_SEND             -1

FxSend::FxSend(int SamplerChannelID, int FxSendID) :
        m_iSamplerChannelID(SamplerChannelID),
        m_iFxSendID(FxSendID), m_bDelete(false), m_bModified(false)
{
        m_MidiCtrl = 91;
        m_Depth    = 0.0f;
}

FxSend::FxSend(int SamplerChannelID) :
        m_iSamplerChannelID(SamplerChannelID),
        m_iFxSendID(NEW_FX_SEND), m_bDelete(false), m_bModified(true)
{
        m_MidiCtrl = 91;
        m_Depth    = 0.0f;
}

FxSend::~FxSend() {
}

int FxSend::id() const {
        return m_iFxSendID;
}

bool FxSend::isNew() const {
        return m_iFxSendID == NEW_FX_SEND;
}

void FxSend::setDeletion(bool bDelete) {
        m_bDelete = bDelete;
        m_bModified = true;
}

bool FxSend::deletion() const {
        return m_bDelete;
}

void FxSend::setName(const QString& sName) {
        m_FxSendName = sName;
        m_bModified = true;
}

bool FxSend::isModified() const {
        return m_bModified;
}

const QString& FxSend::name() const {
        return m_FxSendName;
}

void FxSend::setSendDepthMidiCtrl(int iMidiController) {
        m_MidiCtrl = iMidiController;
        m_bModified = true;
}

int FxSend::sendDepthMidiCtrl() const {
        return m_MidiCtrl;
}

void FxSend::setCurrentDepth(float depth) {
        m_Depth = depth;
        m_bModified = true;
}

float FxSend::currentDepth() const {
        return m_Depth;
}

int FxSend::audioChannel(int iAudioSrc) const {
        if (iAudioSrc < 0 || iAudioSrc >= m_AudioRouting.size())
                return -1;

        return m_AudioRouting[iAudioSrc];
}

bool FxSend::setAudioChannel(int iAudioSrc, int iAudioDst) {
        if (iAudioSrc < 0 || iAudioSrc >= m_AudioRouting.size())
                return false;

        m_AudioRouting[iAudioSrc] = iAudioDst;
        m_bModified = true;

        return true;
}

const FxSendRoutingMap& FxSend::audioRouting() const {
        return m_AudioRouting;
}

bool FxSend::getFromSampler() {
#if CONFIG_FXSEND
        m_bModified = false;

        // in case this is a new, actually not yet existing FX send, ignore update
        if (isNew())
                return true;

        MainForm *pMainForm = MainForm::getInstance();
        if (!pMainForm || !pMainForm->client())
                return false;

        lscp_fxsend_info_t* pFxSendInfo =
                ::lscp_get_fxsend_info(
                        pMainForm->client(),
                        m_iSamplerChannelID,
                        m_iFxSendID);

        if (!pFxSendInfo) {
                pMainForm->appendMessagesClient("lscp_get_fxsend_info");
                return false;
        }

        m_FxSendName = qsamplerUtilities::lscpEscapedTextToRaw(pFxSendInfo->name);
        m_MidiCtrl   = pFxSendInfo->midi_controller;
        m_Depth      = pFxSendInfo->level;

        m_AudioRouting.clear();
        if (pFxSendInfo->audio_routing)
                for (int i = 0; pFxSendInfo->audio_routing[i] != -1; ++i)
                        m_AudioRouting[i] = pFxSendInfo->audio_routing[i];

        return true;
#else // CONFIG_FXSEND
        return false;
#endif // CONFIG_FXSEND
}

bool FxSend::applyToSampler() {
#if CONFIG_FXSEND
        MainForm *pMainForm = MainForm::getInstance();
        if (!pMainForm || !pMainForm->client())
                return false;

        // in case FX send doesn't exist on sampler side yet, create it
        if (isNew()) {
                // doesn't exist and scheduled for deletion? nothing to do
                if (deletion()) {
                        m_bModified = false;
                        return true;
                }

                int result =
                        ::lscp_create_fxsend(
                                pMainForm->client(),
                                m_iSamplerChannelID,
                                m_MidiCtrl, nullptr
                        );
                if (result == -1) {
                        pMainForm->appendMessagesClient("lscp_create_fxsend");
                        return false;
                }
                m_iFxSendID = result;
        }

        lscp_status_t result;

        // delete FX send on sampler side
        if (deletion()) {
                result =
                        ::lscp_destroy_fxsend(
                                pMainForm->client(), m_iSamplerChannelID, m_iFxSendID
                        );
                if (result != LSCP_OK) {
                        pMainForm->appendMessagesClient("lscp_destroy_fxsend");
                        return false;
                }
                m_bModified = false;
                return true;
        }

        // set FX send depth MIDI controller
        result =
                ::lscp_set_fxsend_midi_controller(
                        pMainForm->client(),
                        m_iSamplerChannelID, m_iFxSendID, m_MidiCtrl
                );
        if (result != LSCP_OK) {
                pMainForm->appendMessagesClient("lscp_set_fxsend_midi_controller");
                return false;
        }

#if CONFIG_FXSEND_RENAME
        // set FX send's name
        result =
                ::lscp_set_fxsend_name(
                        pMainForm->client(),
                        m_iSamplerChannelID, m_iFxSendID,
                        qsamplerUtilities::lscpEscapeText(
                                m_FxSendName
                        ).constData()
                );
        if (result != LSCP_OK) {
                pMainForm->appendMessagesClient("lscp_set_fxsend_name");
                return false;
        }
#endif // CONFIG_FXSEND_RENAME

        // set FX send current send level
        result =
                ::lscp_set_fxsend_level(
                        pMainForm->client(),
                        m_iSamplerChannelID, m_iFxSendID, m_Depth
                );
        if (result != LSCP_OK) {
                pMainForm->appendMessagesClient("lscp_set_fxsend_level");
                return false;
        }

        // set FX send's audio routing
        for (int i = 0; i < m_AudioRouting.size(); ++i) {
                result =
                        ::lscp_set_fxsend_audio_channel(
                                pMainForm->client(), m_iSamplerChannelID, m_iFxSendID,
                                i, /*audio source*/
                                m_AudioRouting[i] /*audio destination*/
                        );
                if (result != LSCP_OK) {
                        pMainForm->appendMessagesClient("lscp_set_fxsend_audio_channel");
                        return false;
                }
        }

        m_bModified = false;
        return true;
#else // CONFIG_FXSEND
        return false;
#endif // CONFIG_FXSEND
}

QList<int> FxSend::allFxSendsOfSamplerChannel(int samplerChannelID) {
        QList<int> sends;

        MainForm *pMainForm = MainForm::getInstance();
        if (!pMainForm || !pMainForm->client())
                return sends;

#ifdef CONFIG_FXSEND
        int *piSends = ::lscp_list_fxsends(pMainForm->client(), samplerChannelID);
        if (!piSends) {
                if (::lscp_client_get_errno(pMainForm->client()))
                        pMainForm->appendMessagesClient("lscp_list_fxsends");
        } else {
                for (int iSend = 0; piSends[iSend] >= 0; ++iSend)
                        sends.append(piSends[iSend]);
        }
#endif // CONFIG_FXSEND

        return sends;
}

} // namespace QSampler

// end of qsamplerFxSend.cpp
1	schoenebeck	1667	// qsamplerFxSend.cpp
2			//
3			/****************************************************************************
4	capela	3555	Copyright (C) 2004-2019, rncbc aka Rui Nuno Capela. All rights reserved.
5	schoenebeck	1667	Copyright (C) 2008, Christian Schoenebeck
6
7			This program is free software; you can redistribute it and/or
8			modify it under the terms of the GNU General Public License
9			as published by the Free Software Foundation; either version 2
10			of the License, or (at your option) any later version.
11
12			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License along
18			with this program; if not, write to the Free Software Foundation, Inc.,
19			51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20
21			*****************************************************************************/
22
23			#include "qsamplerAbout.h"
24			#include "qsamplerFxSend.h"
25			#include "qsamplerUtilities.h"
26			#include "qsamplerOptions.h"
27			#include "qsamplerMainForm.h"
28
29			namespace QSampler {
30
31			// marks FxSend objects which don't exist on sampler side yet
32			#define NEW_FX_SEND -1
33
34			FxSend::FxSend(int SamplerChannelID, int FxSendID) :
35			m_iSamplerChannelID(SamplerChannelID),
36			m_iFxSendID(FxSendID), m_bDelete(false), m_bModified(false)
37			{
38			m_MidiCtrl = 91;
39			m_Depth = 0.0f;
40			}
41
42			FxSend::FxSend(int SamplerChannelID) :
43			m_iSamplerChannelID(SamplerChannelID),
44			m_iFxSendID(NEW_FX_SEND), m_bDelete(false), m_bModified(true)
45			{
46			m_MidiCtrl = 91;
47			m_Depth = 0.0f;
48			}
49
50			FxSend::~FxSend() {
51			}
52
53			int FxSend::id() const {
54			return m_iFxSendID;
55			}
56
57			bool FxSend::isNew() const {
58			return m_iFxSendID == NEW_FX_SEND;
59			}
60
61			void FxSend::setDeletion(bool bDelete) {
62			m_bDelete = bDelete;
63			m_bModified = true;
64			}
65
66			bool FxSend::deletion() const {
67			return m_bDelete;
68			}
69
70			void FxSend::setName(const QString& sName) {
71			m_FxSendName = sName;
72			m_bModified = true;
73			}
74
75			bool FxSend::isModified() const {
76			return m_bModified;
77			}
78
79			const QString& FxSend::name() const {
80			return m_FxSendName;
81			}
82
83			void FxSend::setSendDepthMidiCtrl(int iMidiController) {
84			m_MidiCtrl = iMidiController;
85			m_bModified = true;
86			}
87
88			int FxSend::sendDepthMidiCtrl() const {
89			return m_MidiCtrl;
90			}
91
92			void FxSend::setCurrentDepth(float depth) {
93			m_Depth = depth;
94			m_bModified = true;
95			}
96
97			float FxSend::currentDepth() const {
98			return m_Depth;
99			}
100
101			int FxSend::audioChannel(int iAudioSrc) const {
102			if (iAudioSrc < 0 \|\| iAudioSrc >= m_AudioRouting.size())
103			return -1;
104
105			return m_AudioRouting[iAudioSrc];
106			}
107
108			bool FxSend::setAudioChannel(int iAudioSrc, int iAudioDst) {
109			if (iAudioSrc < 0 \|\| iAudioSrc >= m_AudioRouting.size())
110			return false;
111
112			m_AudioRouting[iAudioSrc] = iAudioDst;
113			m_bModified = true;
114
115			return true;
116			}
117
118			const FxSendRoutingMap& FxSend::audioRouting() const {
119			return m_AudioRouting;
120			}
121
122			bool FxSend::getFromSampler() {
123			#if CONFIG_FXSEND
124			m_bModified = false;
125
126			// in case this is a new, actually not yet existing FX send, ignore update
127			if (isNew())
128			return true;
129
130			MainForm *pMainForm = MainForm::getInstance();
131			if (!pMainForm \|\| !pMainForm->client())
132			return false;
133
134			lscp_fxsend_info_t* pFxSendInfo =
135			::lscp_get_fxsend_info(
136			pMainForm->client(),
137			m_iSamplerChannelID,
138			m_iFxSendID);
139
140			if (!pFxSendInfo) {
141			pMainForm->appendMessagesClient("lscp_get_fxsend_info");
142			return false;
143			}
144
145			m_FxSendName = qsamplerUtilities::lscpEscapedTextToRaw(pFxSendInfo->name);
146			m_MidiCtrl = pFxSendInfo->midi_controller;
147			m_Depth = pFxSendInfo->level;
148
149			m_AudioRouting.clear();
150			if (pFxSendInfo->audio_routing)
151	schoenebeck	1668	for (int i = 0; pFxSendInfo->audio_routing[i] != -1; ++i)
152	schoenebeck	1667	m_AudioRouting[i] = pFxSendInfo->audio_routing[i];
153
154			return true;
155			#else // CONFIG_FXSEND
156			return false;
157			#endif // CONFIG_FXSEND
158			}
159
160			bool FxSend::applyToSampler() {
161			#if CONFIG_FXSEND
162			MainForm *pMainForm = MainForm::getInstance();
163			if (!pMainForm \|\| !pMainForm->client())
164			return false;
165
166			// in case FX send doesn't exist on sampler side yet, create it
167			if (isNew()) {
168			// doesn't exist and scheduled for deletion? nothing to do
169			if (deletion()) {
170			m_bModified = false;
171			return true;
172			}
173
174			int result =
175			::lscp_create_fxsend(
176			pMainForm->client(),
177			m_iSamplerChannelID,
178	capela	3555	m_MidiCtrl, nullptr
179	schoenebeck	1667	);
180			if (result == -1) {
181			pMainForm->appendMessagesClient("lscp_create_fxsend");
182			return false;
183			}
184			m_iFxSendID = result;
185			}
186
187			lscp_status_t result;
188
189			// delete FX send on sampler side
190			if (deletion()) {
191			result =
192			::lscp_destroy_fxsend(
193			pMainForm->client(), m_iSamplerChannelID, m_iFxSendID
194			);
195			if (result != LSCP_OK) {
196			pMainForm->appendMessagesClient("lscp_destroy_fxsend");
197			return false;
198			}
199			m_bModified = false;
200			return true;
201			}
202
203			// set FX send depth MIDI controller
204			result =
205			::lscp_set_fxsend_midi_controller(
206			pMainForm->client(),
207			m_iSamplerChannelID, m_iFxSendID, m_MidiCtrl
208			);
209			if (result != LSCP_OK) {
210			pMainForm->appendMessagesClient("lscp_set_fxsend_midi_controller");
211			return false;
212			}
213
214			#if CONFIG_FXSEND_RENAME
215			// set FX send's name
216			result =
217			::lscp_set_fxsend_name(
218			pMainForm->client(),
219			m_iSamplerChannelID, m_iFxSendID,
220			qsamplerUtilities::lscpEscapeText(
221			m_FxSendName
222	capela	3914	).constData()
223	schoenebeck	1667	);
224			if (result != LSCP_OK) {
225			pMainForm->appendMessagesClient("lscp_set_fxsend_name");
226			return false;
227			}
228			#endif // CONFIG_FXSEND_RENAME
229
230			// set FX send current send level
231			result =
232			::lscp_set_fxsend_level(
233			pMainForm->client(),
234			m_iSamplerChannelID, m_iFxSendID, m_Depth
235			);
236			if (result != LSCP_OK) {
237			pMainForm->appendMessagesClient("lscp_set_fxsend_level");
238			return false;
239			}
240
241			// set FX send's audio routing
242			for (int i = 0; i < m_AudioRouting.size(); ++i) {
243			result =
244			::lscp_set_fxsend_audio_channel(
245			pMainForm->client(), m_iSamplerChannelID, m_iFxSendID,
246			i, /audio source/
247			m_AudioRouting[i] /audio destination/
248			);
249			if (result != LSCP_OK) {
250			pMainForm->appendMessagesClient("lscp_set_fxsend_audio_channel");
251			return false;
252			}
253			}
254
255			m_bModified = false;
256			return true;
257			#else // CONFIG_FXSEND
258			return false;
259			#endif // CONFIG_FXSEND
260			}
261
262			QList<int> FxSend::allFxSendsOfSamplerChannel(int samplerChannelID) {
263			QList<int> sends;
264
265			MainForm *pMainForm = MainForm::getInstance();
266			if (!pMainForm \|\| !pMainForm->client())
267			return sends;
268
269			#ifdef CONFIG_FXSEND
270			int *piSends = ::lscp_list_fxsends(pMainForm->client(), samplerChannelID);
271			if (!piSends) {
272			if (::lscp_client_get_errno(pMainForm->client()))
273			pMainForm->appendMessagesClient("lscp_list_fxsends");
274			} else {
275			for (int iSend = 0; piSends[iSend] >= 0; ++iSend)
276			sends.append(piSends[iSend]);
277			}
278			#endif // CONFIG_FXSEND
279
280			return sends;
281			}
282
283			} // namespace QSampler
284
285			// end of qsamplerFxSend.cpp