trunk/src/qsamplerInstrument.cpp

// qsamplerInstrument.cpp
//
/****************************************************************************
   Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.

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