trunk/src/qsamplerInstrument.cpp

// qsamplerInstrument.cpp
//
/****************************************************************************
   Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
   Copyright (C) 2007, 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 "qsamplerUtilities.h"
#include "qsamplerAbout.h"
#include "qsamplerInstrument.h"

#include "qsamplerMainForm.h"

using namespace QSampler;

//-------------------------------------------------------------------------
// qsamplerInstrument - MIDI instrument map structure.
//

// Constructor.
qsamplerInstrument::qsamplerInstrument ( int iMap, int iBank, int iProg )
{
        m_iMap          = iMap;
        m_iBank         = iBank;
        m_iProg         = iProg;
        m_iInstrumentNr = 0;;
        m_fVolume       = 1.0f;
        m_iLoadMode     = 0;
}

// Default destructor.
qsamplerInstrument::~qsamplerInstrument (void)
{
}


// Instrument accessors.
void qsamplerInstrument::setMap ( int iMap )
{
        m_iMap = iMap;
}

int qsamplerInstrument::map (void) const
{
        return m_iMap;
}


void qsamplerInstrument::setBank ( int iBank )
{
        m_iBank = iBank;
}

int qsamplerInstrument::bank (void) const
{
        return m_iBank;
}


void qsamplerInstrument::setProg ( int iProg )
{
        m_iProg = iProg;
}

int qsamplerInstrument::prog (void) const
{
        return m_iProg;
}


void qsamplerInstrument::setName ( const QString& sName )
{
        m_sName = sName;
}

const QString& qsamplerInstrument::name (void) const
{
        return m_sName;
}


void qsamplerInstrument::setEngineName ( const QString& sEngineName )
{
        m_sEngineName = sEngineName;
}

const QString& qsamplerInstrument::engineName (void) const
{
        return m_sEngineName;
}


void qsamplerInstrument::setInstrumentFile ( const QString& sInstrumentFile )
{
        m_sInstrumentFile = sInstrumentFile;
}

const QString& qsamplerInstrument::instrumentFile (void) const
{
        return m_sInstrumentFile;
}


const QString& qsamplerInstrument::instrumentName (void) const
{
        return m_sInstrumentName;
}


void qsamplerInstrument::setInstrumentNr ( int iInstrumentNr )
{
        m_iInstrumentNr = iInstrumentNr;
}

int qsamplerInstrument::instrumentNr (void) const
{
        return m_iInstrumentNr;
}


void qsamplerInstrument::setVolume ( float fVolume )
{
        m_fVolume = fVolume;
}

float qsamplerInstrument::volume (void) const
{
        return m_fVolume;
}


void qsamplerInstrument::setLoadMode ( int iLoadMode )
{
        m_iLoadMode = iLoadMode;
}

int qsamplerInstrument::loadMode (void) const
{
        return m_iLoadMode;
}


// Sync methods.
bool qsamplerInstrument::mapInstrument (void)
{
#ifdef CONFIG_MIDI_INSTRUMENT

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

        if (m_iMap < 0 || m_iBank < 0 || m_iProg < 0)
                return false;

        lscp_midi_instrument_t instr;

        instr.map  = m_iMap;
        instr.bank = (m_iBank & 0x0fff);
        instr.prog = (m_iProg & 0x7f);

        lscp_load_mode_t load_mode;
        switch (m_iLoadMode) {
                case 3:
                        load_mode = LSCP_LOAD_PERSISTENT;
                        break;
                case 2:
                        load_mode = LSCP_LOAD_ON_DEMAND_HOLD;
                        break;
                case 1:
                        load_mode = LSCP_LOAD_ON_DEMAND;
                        break;
                case 0:
                default:
                        load_mode = LSCP_LOAD_DEFAULT;
                        break;
        }

        if (::lscp_map_midi_instrument(pMainForm->client(), &instr,
                        m_sEngineName.latin1(),
                        qsamplerUtilities::lscpEscapePath(m_sInstrumentFile).latin1(),
                        m_iInstrumentNr,
                        m_fVolume,
                        load_mode,
                        m_sName.latin1()) != LSCP_OK) {
                pMainForm->appendMessagesClient("lscp_map_midi_instrument");
                return false;
        }

        return true;

#else

        return false;

#endif
}


bool qsamplerInstrument::unmapInstrument (void)
{
#ifdef CONFIG_MIDI_INSTRUMENT

        if (m_iMap < 0 || m_iBank < 0 || m_iProg < 0)
                return false;

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

        lscp_midi_instrument_t instr;

        instr.map  = m_iMap;
        instr.bank = (m_iBank & 0x0fff);
        instr.prog = (m_iProg & 0x7f);

        if (::lscp_unmap_midi_instrument(pMainForm->client(), &instr) != LSCP_OK) {
                pMainForm->appendMessagesClient("lscp_unmap_midi_instrument");
                return false;
        }

        return true;

#else

        return false;

#endif
}


bool qsamplerInstrument::getInstrument (void)
{
#ifdef CONFIG_MIDI_INSTRUMENT

        if (m_iMap < 0 || m_iBank < 0 || m_iProg < 0)
                return false;

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

        lscp_midi_instrument_t instr;

        instr.map  = m_iMap;
        instr.bank = (m_iBank & 0x0fff);
        instr.prog = (m_iProg & 0x7f);

        lscp_midi_instrument_info_t *pInstrInfo
                = ::lscp_get_midi_instrument_info(pMainForm->client(), &instr);
        if (pInstrInfo == NULL) {
                pMainForm->appendMessagesClient("lscp_get_midi_instrument_info");
                return false;
        }

        m_sName           = qsamplerUtilities::lscpEscapedTextToRaw(pInstrInfo->name);
        m_sEngineName     = pInstrInfo->engine_name;
        m_sInstrumentName = qsamplerUtilities::lscpEscapedTextToRaw(pInstrInfo->instrument_name);
        m_sInstrumentFile = qsamplerUtilities::lscpEscapedPathToPosix(pInstrInfo->instrument_file);
        m_iInstrumentNr   = pInstrInfo->instrument_nr;
        m_fVolume         = pInstrInfo->volume;

        switch (pInstrInfo->load_mode) {
                case LSCP_LOAD_PERSISTENT:
                        m_iLoadMode = 3;
                        break;
                case LSCP_LOAD_ON_DEMAND_HOLD:
                        m_iLoadMode = 2;
                        break;
                case LSCP_LOAD_ON_DEMAND:
                        m_iLoadMode = 1;
                        break;
                case LSCP_LOAD_DEFAULT:
                default:
                        m_iLoadMode = 0;
                        break;
        }

        // Fix something.
        if (m_sName.isEmpty())
                m_sName = m_sInstrumentName;

        return true;

#else

        return false;

#endif
}


// Instrument map name enumerator.
QStringList qsamplerInstrument::getMapNames (void)
{
        QStringList maps;

        MainForm *pMainForm = MainForm::getInstance();
        if (pMainForm == NULL)
                return maps;
        if (pMainForm->client() == NULL)
                return maps;

#ifdef CONFIG_MIDI_INSTRUMENT
        int *piMaps = ::lscp_list_midi_instrument_maps(pMainForm->client());
        if (piMaps == NULL) {
                if (::lscp_client_get_errno(pMainForm->client()))
                        pMainForm->appendMessagesClient("lscp_list_midi_instruments");
        } else {
                for (int iMap = 0; piMaps[iMap] >= 0; iMap++) {
                        const QString& sMapName = getMapName(piMaps[iMap]);
                        if (!sMapName.isEmpty())
                                maps.append(sMapName);
                }
        }
#endif

        return maps;
}

// Instrument map name enumerator.
QString qsamplerInstrument::getMapName ( int iMidiMap )
{
        QString sMapName;

        MainForm *pMainForm = MainForm::getInstance();
        if (pMainForm == NULL)
                return sMapName;
        if (pMainForm->client() == NULL)
                return sMapName;

#ifdef CONFIG_MIDI_INSTRUMENT
        const char *pszMapName
                = ::lscp_get_midi_instrument_map_name(pMainForm->client(), iMidiMap);
        if (pszMapName == NULL) {
                pszMapName = " -";
                if (::lscp_client_get_errno(pMainForm->client()))
                        pMainForm->appendMessagesClient("lscp_get_midi_instrument_name");
        }
        sMapName = QString("%1 - %2").arg(iMidiMap).arg(qsamplerUtilities::lscpEscapedTextToRaw(pszMapName));
#endif

        return sMapName;
}


// end of qsamplerInstrument.cpp
1	capela	964	// qsamplerInstrument.cpp
2			//
3			/****************************************************************************
4	schoenebeck	1386	Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5	capela	1464	Copyright (C) 2007, Christian Schoenebeck
6	capela	964
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	schoenebeck	1386	#include "qsamplerUtilities.h"
24	capela	964	#include "qsamplerAbout.h"
25			#include "qsamplerInstrument.h"
26
27			#include "qsamplerMainForm.h"
28
29	schoenebeck	1461	using namespace QSampler;
30	capela	964
31			//-------------------------------------------------------------------------
32			// qsamplerInstrument - MIDI instrument map structure.
33			//
34
35			// Constructor.
36	capela	980	qsamplerInstrument::qsamplerInstrument ( int iMap, int iBank, int iProg )
37	capela	964	{
38	capela	980	m_iMap = iMap;
39	capela	964	m_iBank = iBank;
40	capela	980	m_iProg = iProg;
41	capela	964	m_iInstrumentNr = 0;;
42			m_fVolume = 1.0f;
43			m_iLoadMode = 0;
44			}
45
46			// Default destructor.
47			qsamplerInstrument::~qsamplerInstrument (void)
48			{
49			}
50
51
52			// Instrument accessors.
53	capela	980	void qsamplerInstrument::setMap ( int iMap )
54			{
55			m_iMap = iMap;
56			}
57
58			int qsamplerInstrument::map (void) const
59			{
60			return m_iMap;
61			}
62
63
64	capela	964	void qsamplerInstrument::setBank ( int iBank )
65			{
66			m_iBank = iBank;
67			}
68
69			int qsamplerInstrument::bank (void) const
70			{
71			return m_iBank;
72			}
73
74
75	capela	980	void qsamplerInstrument::setProg ( int iProg )
76	capela	964	{
77	capela	980	m_iProg = iProg;
78	capela	964	}
79
80	capela	980	int qsamplerInstrument::prog (void) const
81	capela	964	{
82	capela	980	return m_iProg;
83	capela	964	}
84
85
86			void qsamplerInstrument::setName ( const QString& sName )
87			{
88			m_sName = sName;
89			}
90
91			const QString& qsamplerInstrument::name (void) const
92			{
93			return m_sName;
94			}
95
96
97			void qsamplerInstrument::setEngineName ( const QString& sEngineName )
98			{
99			m_sEngineName = sEngineName;
100			}
101
102			const QString& qsamplerInstrument::engineName (void) const
103			{
104			return m_sEngineName;
105			}
106
107
108			void qsamplerInstrument::setInstrumentFile ( const QString& sInstrumentFile )
109			{
110			m_sInstrumentFile = sInstrumentFile;
111			}
112
113			const QString& qsamplerInstrument::instrumentFile (void) const
114			{
115			return m_sInstrumentFile;
116			}
117
118
119			const QString& qsamplerInstrument::instrumentName (void) const
120			{
121			return m_sInstrumentName;
122			}
123
124
125			void qsamplerInstrument::setInstrumentNr ( int iInstrumentNr )
126			{
127			m_iInstrumentNr = iInstrumentNr;
128			}
129
130			int qsamplerInstrument::instrumentNr (void) const
131			{
132			return m_iInstrumentNr;
133			}
134
135
136			void qsamplerInstrument::setVolume ( float fVolume )
137			{
138			m_fVolume = fVolume;
139			}
140
141			float qsamplerInstrument::volume (void) const
142			{
143			return m_fVolume;
144			}
145
146
147			void qsamplerInstrument::setLoadMode ( int iLoadMode )
148			{
149			m_iLoadMode = iLoadMode;
150			}
151
152			int qsamplerInstrument::loadMode (void) const
153			{
154			return m_iLoadMode;
155			}
156
157
158			// Sync methods.
159	capela	980	bool qsamplerInstrument::mapInstrument (void)
160	capela	964	{
161			#ifdef CONFIG_MIDI_INSTRUMENT
162
163	schoenebeck	1461	MainForm *pMainForm = MainForm::getInstance();
164	capela	964	if (pMainForm == NULL)
165			return false;
166			if (pMainForm->client() == NULL)
167			return false;
168
169	capela	980	if (m_iMap < 0 \|\| m_iBank < 0 \|\| m_iProg < 0)
170	capela	964	return false;
171
172			lscp_midi_instrument_t instr;
173
174	capela	980	instr.map = m_iMap;
175			instr.bank = (m_iBank & 0x0fff);
176			instr.prog = (m_iProg & 0x7f);
177	capela	964
178			lscp_load_mode_t load_mode;
179			switch (m_iLoadMode) {
180			case 3:
181			load_mode = LSCP_LOAD_PERSISTENT;
182			break;
183			case 2:
184			load_mode = LSCP_LOAD_ON_DEMAND_HOLD;
185			break;
186			case 1:
187			load_mode = LSCP_LOAD_ON_DEMAND;
188			break;
189			case 0:
190			default:
191			load_mode = LSCP_LOAD_DEFAULT;
192			break;
193			}
194
195			if (::lscp_map_midi_instrument(pMainForm->client(), &instr,
196	capela	987	m_sEngineName.latin1(),
197	schoenebeck	1402	qsamplerUtilities::lscpEscapePath(m_sInstrumentFile).latin1(),
198	capela	987	m_iInstrumentNr,
199			m_fVolume,
200			load_mode,
201			m_sName.latin1()) != LSCP_OK) {
202	capela	964	pMainForm->appendMessagesClient("lscp_map_midi_instrument");
203			return false;
204			}
205
206			return true;
207
208			#else
209
210			return false;
211
212			#endif
213			}
214
215
216	capela	980	bool qsamplerInstrument::unmapInstrument (void)
217	capela	964	{
218			#ifdef CONFIG_MIDI_INSTRUMENT
219
220	capela	980	if (m_iMap < 0 \|\| m_iBank < 0 \|\| m_iProg < 0)
221	capela	964	return false;
222
223	schoenebeck	1461	MainForm *pMainForm = MainForm::getInstance();
224	capela	964	if (pMainForm == NULL)
225			return false;
226			if (pMainForm->client() == NULL)
227			return false;
228
229			lscp_midi_instrument_t instr;
230
231	capela	980	instr.map = m_iMap;
232			instr.bank = (m_iBank & 0x0fff);
233			instr.prog = (m_iProg & 0x7f);
234	capela	964
235			if (::lscp_unmap_midi_instrument(pMainForm->client(), &instr) != LSCP_OK) {
236			pMainForm->appendMessagesClient("lscp_unmap_midi_instrument");
237			return false;
238			}
239
240			return true;
241
242			#else
243
244			return false;
245
246			#endif
247			}
248
249
250	capela	980	bool qsamplerInstrument::getInstrument (void)
251	capela	964	{
252			#ifdef CONFIG_MIDI_INSTRUMENT
253
254	capela	980	if (m_iMap < 0 \|\| m_iBank < 0 \|\| m_iProg < 0)
255	capela	964	return false;
256
257	schoenebeck	1461	MainForm *pMainForm = MainForm::getInstance();
258	capela	964	if (pMainForm == NULL)
259			return false;
260			if (pMainForm->client() == NULL)
261			return false;
262
263			lscp_midi_instrument_t instr;
264
265	capela	980	instr.map = m_iMap;
266			instr.bank = (m_iBank & 0x0fff);
267			instr.prog = (m_iProg & 0x7f);
268	capela	964
269			lscp_midi_instrument_info_t *pInstrInfo
270			= ::lscp_get_midi_instrument_info(pMainForm->client(), &instr);
271			if (pInstrInfo == NULL) {
272			pMainForm->appendMessagesClient("lscp_get_midi_instrument_info");
273			return false;
274			}
275
276	schoenebeck	1402	m_sName = qsamplerUtilities::lscpEscapedTextToRaw(pInstrInfo->name);
277	capela	964	m_sEngineName = pInstrInfo->engine_name;
278	schoenebeck	1402	m_sInstrumentName = qsamplerUtilities::lscpEscapedTextToRaw(pInstrInfo->instrument_name);
279			m_sInstrumentFile = qsamplerUtilities::lscpEscapedPathToPosix(pInstrInfo->instrument_file);
280	capela	964	m_iInstrumentNr = pInstrInfo->instrument_nr;
281			m_fVolume = pInstrInfo->volume;
282
283			switch (pInstrInfo->load_mode) {
284			case LSCP_LOAD_PERSISTENT:
285			m_iLoadMode = 3;
286			break;
287			case LSCP_LOAD_ON_DEMAND_HOLD:
288			m_iLoadMode = 2;
289			break;
290			case LSCP_LOAD_ON_DEMAND:
291			m_iLoadMode = 1;
292			break;
293			case LSCP_LOAD_DEFAULT:
294			default:
295			m_iLoadMode = 0;
296			break;
297			}
298
299			// Fix something.
300			if (m_sName.isEmpty())
301			m_sName = m_sInstrumentName;
302
303			return true;
304
305			#else
306
307			return false;
308
309			#endif
310			}
311
312
313	capela	980	// Instrument map name enumerator.
314			QStringList qsamplerInstrument::getMapNames (void)
315			{
316			QStringList maps;
317
318	schoenebeck	1461	MainForm *pMainForm = MainForm::getInstance();
319	capela	980	if (pMainForm == NULL)
320			return maps;
321			if (pMainForm->client() == NULL)
322			return maps;
323
324			#ifdef CONFIG_MIDI_INSTRUMENT
325			int *piMaps = ::lscp_list_midi_instrument_maps(pMainForm->client());
326	capela	987	if (piMaps == NULL) {
327			if (::lscp_client_get_errno(pMainForm->client()))
328			pMainForm->appendMessagesClient("lscp_list_midi_instruments");
329			} else {
330			for (int iMap = 0; piMaps[iMap] >= 0; iMap++) {
331			const QString& sMapName = getMapName(piMaps[iMap]);
332			if (!sMapName.isEmpty())
333			maps.append(sMapName);
334			}
335	capela	980	}
336			#endif
337
338			return maps;
339			}
340
341			// Instrument map name enumerator.
342			QString qsamplerInstrument::getMapName ( int iMidiMap )
343			{
344			QString sMapName;
345
346	schoenebeck	1461	MainForm *pMainForm = MainForm::getInstance();
347	capela	980	if (pMainForm == NULL)
348			return sMapName;
349			if (pMainForm->client() == NULL)
350			return sMapName;
351
352			#ifdef CONFIG_MIDI_INSTRUMENT
353			const char *pszMapName
354			= ::lscp_get_midi_instrument_map_name(pMainForm->client(), iMidiMap);
355	capela	987	if (pszMapName == NULL) {
356	capela	980	pszMapName = " -";
357	capela	987	if (::lscp_client_get_errno(pMainForm->client()))
358			pMainForm->appendMessagesClient("lscp_get_midi_instrument_name");
359			}
360	schoenebeck	1402	sMapName = QString("%1 - %2").arg(iMidiMap).arg(qsamplerUtilities::lscpEscapedTextToRaw(pszMapName));
361	capela	980	#endif
362
363			return sMapName;
364			}
365
366
367	capela	964	// end of qsamplerInstrument.cpp