trunk/src/qsamplerChannel.cpp

// qsamplerChannel.cpp
//
/****************************************************************************
   Copyright (C) 2003-2005, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

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

#include "qsamplerChannel.h"

#include "qsamplerMainForm.h"
#include "qsamplerChannelForm.h"

#include "config.h"

#include <qfileinfo.h>

#ifdef CONFIG_LIBGIG
#include "gig.h"
#endif

#define QSAMPLER_INSTRUMENT_MAX 8


//-------------------------------------------------------------------------
// qsamplerChannel - Sampler channel structure.
//

// Constructor.
qsamplerChannel::qsamplerChannel ( qsamplerMainForm *pMainForm, int iChannelID )
{
    m_pMainForm  = pMainForm;
    m_iChannelID = iChannelID;

//  m_sEngineName       = QObject::tr("(No engine)");
//  m_sInstrumentName   = QObject::tr("(No instrument)");
//  m_sInstrumentFile   = m_sInstrumentName;
    m_iInstrumentNr     = -1;
    m_iInstrumentStatus = -1;
    m_sMidiDriver       = "Alsa";   // DEPRECATED.
    m_iMidiDevice       = -1;
    m_iMidiPort         = -1;
    m_iMidiChannel      = -1;
    m_sAudioDriver      = "Alsa";   // DEPRECATED.
    m_iAudioDevice      = -1;
    m_fVolume           = 0.0;

}

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


// The global options settings delegated property.
qsamplerOptions *qsamplerChannel::options (void)
{
    if (m_pMainForm == NULL)
        return NULL;

    return m_pMainForm->options();
}


// The client descriptor delegated property.
lscp_client_t *qsamplerChannel::client (void)
{
    if (m_pMainForm == NULL)
        return NULL;

    return m_pMainForm->client();
}


// Create a new sampler channel, if not already.
bool qsamplerChannel::addChannel (void)
{
    if (client() == NULL)
        return false;

    // Are we a new channel?
    if (m_iChannelID < 0) {
        m_iChannelID = ::lscp_add_channel(client());
        if (m_iChannelID < 0) {
            appendMessagesClient("lscp_add_channel");
            appendMessagesError(QObject::tr("Could not create the new channel.\n\nSorry."));
        }   // Otherwise it's created...
        else appendMessages(QObject::tr("Channel %1 created.").arg(m_iChannelID));
    }

    // Return whether we're a valid channel...
    return (m_iChannelID >= 0);
}


// Remove sampler channel.
bool qsamplerChannel::removeChannel (void)
{
    if (client() == NULL)
        return false;

    // Are we an existing channel?
    if (m_iChannelID >= 0) {
        if (::lscp_remove_channel(client(), m_iChannelID) != LSCP_OK) {
            appendMessagesClient("lscp_remove_channel");
            appendMessagesError(QObject::tr("Could not remove channel.\n\nSorry."));
        } else {
            // Otherwise it's removed.
            appendMessages(QObject::tr("Channel %1 removed.").arg(m_iChannelID));
            m_iChannelID = -1;
        }
    }
    
    // Return whether we've removed the channel...
    return (m_iChannelID < 0);
}


// Channel-ID (aka Sammpler-Channel) accessors.
int qsamplerChannel::channelID (void)
{
    return m_iChannelID;
}

void qsamplerChannel::setChannelID ( int iChannelID )
{
    m_iChannelID = iChannelID;
}


// Readable channel name.
QString qsamplerChannel::channelName (void)
{
    return (m_iChannelID < 0 ? QObject::tr("New Channel") : QObject::tr("Channel %1").arg(m_iChannelID));
}


// Engine name accessors.
QString& qsamplerChannel::engineName (void)
{
    return m_sEngineName;
}

bool qsamplerChannel::loadEngine ( const QString& sEngineName )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_load_engine(client(), sEngineName.latin1(), m_iChannelID) != LSCP_OK) {
        appendMessagesClient("lscp_load_engine");
        return false;
    }

    m_sEngineName = sEngineName;
    return true;
}


// Instrument name accessor.
QString& qsamplerChannel::instrumentName (void)
{
    return m_sInstrumentName;
}

// Instrument filename accessor.
QString& qsamplerChannel::instrumentFile (void)
{
    return m_sInstrumentFile;
}

// Instrument index accessor.
int qsamplerChannel::instrumentNr (void)
{
    return m_iInstrumentNr;
}

// Instrument status accessor.
int qsamplerChannel::instrumentStatus (void)
{
    return m_iInstrumentStatus;
}

// Instrument file loader.
bool qsamplerChannel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_load_instrument_non_modal(client(), sInstrumentFile.latin1(), iInstrumentNr, m_iChannelID) != LSCP_OK) {
        appendMessagesClient("lscp_load_instrument");
        return false;
    }

    m_sInstrumentName = getInstrumentName(sInstrumentFile, iInstrumentNr, true);
    m_sInstrumentFile = sInstrumentFile;
    m_iInstrumentNr = iInstrumentNr;
    m_iInstrumentStatus = 0;

    return true;
}


// MIDI driver type accessors (DEPRECATED).
QString& qsamplerChannel::midiDriver (void)
{
    return m_sMidiDriver;
}

bool qsamplerChannel::setMidiDriver ( const QString& sMidiDriver )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_set_channel_midi_type(client(), m_iChannelID, sMidiDriver.latin1()) != LSCP_OK) {
        appendMessagesClient("lscp_set_channel_midi_type");
        return false;
    }

    m_sMidiDriver = sMidiDriver;
    return true;
}


// MIDI device accessors.
int qsamplerChannel::midiDevice (void)
{
    return m_iMidiDevice;
}

bool qsamplerChannel::setMidiDevice ( int iMidiDevice )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_set_channel_midi_device(client(), m_iChannelID, iMidiDevice) != LSCP_OK) {
        appendMessagesClient("lscp_set_channel_midi_device");
        return false;
    }

    m_iMidiDevice = iMidiDevice;
    return true;
}


// MIDI port number accessor.
int qsamplerChannel::midiPort (void)
{
    return m_iMidiPort;
}

bool qsamplerChannel::setMidiPort ( int iMidiPort )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_set_channel_midi_port(client(), m_iChannelID, iMidiPort) != LSCP_OK) {
        appendMessagesClient("lscp_set_channel_midi_port");
        return false;
    }

    m_iMidiPort = iMidiPort;
    return true;
}


// MIDI channel accessor.
int qsamplerChannel::midiChannel (void)
{
    return m_iMidiChannel;
}

bool qsamplerChannel::setMidiChannel ( int iMidiChannel )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_set_channel_midi_channel(client(), m_iChannelID, iMidiChannel) != LSCP_OK) {
        appendMessagesClient("lscp_set_channel_midi_channel");
        return false;
    }

    m_iMidiChannel = iMidiChannel;
    return true;
}


// Audio device accessor.
int qsamplerChannel::audioDevice (void)
{
    return m_iAudioDevice;
}

bool qsamplerChannel::setAudioDevice ( int iAudioDevice )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_set_channel_audio_device(client(), m_iChannelID, iAudioDevice) != LSCP_OK) {
        appendMessagesClient("lscp_set_channel_audio_device");
        return false;
    }

    m_iAudioDevice = iAudioDevice;
    return true;
}


// Audio driver type accessors (DEPRECATED).
QString& qsamplerChannel::audioDriver (void)
{
    return m_sAudioDriver;
}

bool qsamplerChannel::setAudioDriver ( const QString& sAudioDriver )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_set_channel_audio_type(client(), m_iChannelID, sAudioDriver.latin1()) != LSCP_OK) {
        appendMessagesClient("lscp_set_channel_audio_type");
        return false;
    }

    m_sAudioDriver = sAudioDriver;
    return true;
}


// Channel volume accessors.
float qsamplerChannel::volume (void)
{
    return m_fVolume;
}

bool qsamplerChannel::setVolume ( float fVolume )
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_set_channel_volume(client(), m_iChannelID, fVolume) != LSCP_OK) {
        appendMessagesClient("lscp_set_channel_volume");
        return false;
    }

    m_fVolume = fVolume;
    return true;
}


// Istrument name remapper.
void qsamplerChannel::updateInstrumentName (void)
{
        m_sInstrumentName = getInstrumentName(m_sInstrumentFile,
                m_iInstrumentNr, (options() && options()->bInstrumentNames));
}


// Update whole channel info state.
bool qsamplerChannel::updateChannelInfo (void)
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    // Read channel information.
    lscp_channel_info_t *pChannelInfo = ::lscp_get_channel_info(client(), m_iChannelID);
    if (pChannelInfo == NULL) {
        appendMessagesClient("lscp_get_channel_info");
        appendMessagesError(QObject::tr("Could not get channel information.\n\nSorry."));
        return false;
    }

        // First, check if intrument name has changed,
        // taking care that instrument name lookup might be expensive,
        // so we better make it only once and when really needed...
        if ((m_sInstrumentFile != pChannelInfo->instrument_file) ||
                (m_iInstrumentNr   != pChannelInfo->instrument_nr)) {
                m_sInstrumentFile = pChannelInfo->instrument_file;
                m_iInstrumentNr   = pChannelInfo->instrument_nr;
                updateInstrumentName();
        }
    // Cache in other channel information.
    m_sEngineName       = pChannelInfo->engine_name;
    m_iInstrumentStatus = pChannelInfo->instrument_status;
    m_iMidiDevice       = pChannelInfo->midi_device;
    m_iMidiPort         = pChannelInfo->midi_port;
    m_iMidiChannel      = pChannelInfo->midi_channel;
    m_iAudioDevice      = pChannelInfo->audio_device;
    m_fVolume           = pChannelInfo->volume;
    // Some sanity checks.
    if (m_sEngineName == "NONE")
        m_sEngineName = QString::null;
    if (m_sInstrumentFile == "NONE") {
        m_sInstrumentFile = QString::null;
        m_sInstrumentName = QString::null;
        }

    return true;
}


// Reset channel method.
bool qsamplerChannel::resetChannel (void)
{
    if (client() == NULL || m_iChannelID < 0)
        return false;

    if (::lscp_reset_channel(client(), m_iChannelID) != LSCP_OK) {
        appendMessagesClient("lscp_reset_channel");
        return false;
    }

    appendMessages(QObject::tr("Channel %1 reset.").arg(m_iChannelID));
    return true;
}


// Channel setup dialog form.
bool qsamplerChannel::channelSetup ( QWidget *pParent )
{
    bool bResult = false;

    qsamplerChannelForm *pChannelForm = new qsamplerChannelForm(pParent);
    if (pChannelForm) {
        pChannelForm->setup(this);
        bResult = pChannelForm->exec();
        delete pChannelForm;
    }

    return bResult;
}


// Redirected messages output methods.
void qsamplerChannel::appendMessages( const QString& s )
{
    if (m_pMainForm) m_pMainForm->appendMessages(s);
}

void qsamplerChannel::appendMessagesColor( const QString& s, const QString& c )
{
    if (m_pMainForm) m_pMainForm->appendMessagesColor(s, c);
}

void qsamplerChannel::appendMessagesText( const QString& s )
{
    if (m_pMainForm) m_pMainForm->appendMessagesText(s);
}

void qsamplerChannel::appendMessagesError( const QString& s )
{
    if (m_pMainForm) m_pMainForm->appendMessagesError(s);
}

void qsamplerChannel::appendMessagesClient( const QString& s )
{
    if (m_pMainForm) m_pMainForm->appendMessagesClient(s);
}


// Context menu event handler.
void qsamplerChannel::contextMenuEvent( QContextMenuEvent *pEvent )
{
    if (m_pMainForm) m_pMainForm->contextMenuEvent(pEvent);
}


// Retrieve the instrument list of a instrument file (.gig).
QStringList qsamplerChannel::getInstrumentList( const QString& sInstrumentFile,
        bool bInstrumentNames )
{
    QFileInfo fileinfo(sInstrumentFile);
    QString sInstrumentName = fileinfo.fileName();
    QStringList instlist;

    if (fileinfo.exists()) {
#ifdef CONFIG_LIBGIG
                if (bInstrumentNames) {
                RIFF::File *pRiff = new RIFF::File(sInstrumentFile);
                gig::File  *pGig  = new gig::File(pRiff);
                gig::Instrument *pInstrument = pGig->GetFirstInstrument();
                while (pInstrument) {
                    instlist.append((pInstrument->pInfo)->Name.c_str());
                    pInstrument = pGig->GetNextInstrument();
                }
                delete pGig;
                delete pRiff;
                }
                else
#endif
        for (int iInstrumentNr = 0; iInstrumentNr < QSAMPLER_INSTRUMENT_MAX; iInstrumentNr++)
            instlist.append(sInstrumentName + " [" + QString::number(iInstrumentNr) + "]");
    }
    else instlist.append(sInstrumentName);

    return instlist;
}


// Retrieve the spacific instrument name of a instrument file (.gig), given its index.
QString qsamplerChannel::getInstrumentName( const QString& sInstrumentFile,
        int iInstrumentNr, bool bInstrumentNames )
{
    QFileInfo fileinfo(sInstrumentFile);
    QString sInstrumentName = fileinfo.fileName();

    if (fileinfo.exists()) {
#ifdef CONFIG_LIBGIG
                if (bInstrumentNames) {
                RIFF::File *pRiff = new RIFF::File(sInstrumentFile);
                gig::File  *pGig  = new gig::File(pRiff);
                int iIndex = 0;
                gig::Instrument *pInstrument = pGig->GetFirstInstrument();
                while (pInstrument) {
                    if (iIndex == iInstrumentNr) {
                        sInstrumentName = (pInstrument->pInfo)->Name.c_str();
                        break;
                    }
                    iIndex++;
                    pInstrument = pGig->GetNextInstrument();
                }
                delete pGig;
                delete pRiff;
                }
                else
#endif
        sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
    }

    return sInstrumentName;
}


// end of qsamplerChannel.cpp
1	// qsamplerChannel.cpp
2	//
3	/****************************************************************************
4	Copyright (C) 2003-2005, rncbc aka Rui Nuno Capela. All rights reserved.
5
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
17	along with this program; if not, write to the Free Software
18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20	*****************************************************************************/
21
22	#include "qsamplerChannel.h"
23
24	#include "qsamplerMainForm.h"
25	#include "qsamplerChannelForm.h"
26
27	#include "config.h"
28
29	#include <qfileinfo.h>
30
31	#ifdef CONFIG_LIBGIG
32	#include "gig.h"
33	#endif
34
35	#define QSAMPLER_INSTRUMENT_MAX 8
36
37
38	//-------------------------------------------------------------------------
39	// qsamplerChannel - Sampler channel structure.
40	//
41
42	// Constructor.
43	qsamplerChannel::qsamplerChannel ( qsamplerMainForm *pMainForm, int iChannelID )
44	{
45	m_pMainForm = pMainForm;
46	m_iChannelID = iChannelID;
47
48	// m_sEngineName = QObject::tr("(No engine)");
49	// m_sInstrumentName = QObject::tr("(No instrument)");
50	// m_sInstrumentFile = m_sInstrumentName;
51	m_iInstrumentNr = -1;
52	m_iInstrumentStatus = -1;
53	m_sMidiDriver = "Alsa"; // DEPRECATED.
54	m_iMidiDevice = -1;
55	m_iMidiPort = -1;
56	m_iMidiChannel = -1;
57	m_sAudioDriver = "Alsa"; // DEPRECATED.
58	m_iAudioDevice = -1;
59	m_fVolume = 0.0;
60
61	}
62
63	// Default destructor.
64	qsamplerChannel::~qsamplerChannel (void)
65	{
66	}
67
68
69	// The global options settings delegated property.
70	qsamplerOptions *qsamplerChannel::options (void)
71	{
72	if (m_pMainForm == NULL)
73	return NULL;
74
75	return m_pMainForm->options();
76	}
77
78
79	// The client descriptor delegated property.
80	lscp_client_t *qsamplerChannel::client (void)
81	{
82	if (m_pMainForm == NULL)
83	return NULL;
84
85	return m_pMainForm->client();
86	}
87
88
89	// Create a new sampler channel, if not already.
90	bool qsamplerChannel::addChannel (void)
91	{
92	if (client() == NULL)
93	return false;
94
95	// Are we a new channel?
96	if (m_iChannelID < 0) {
97	m_iChannelID = ::lscp_add_channel(client());
98	if (m_iChannelID < 0) {
99	appendMessagesClient("lscp_add_channel");
100	appendMessagesError(QObject::tr("Could not create the new channel.\n\nSorry."));
101	} // Otherwise it's created...
102	else appendMessages(QObject::tr("Channel %1 created.").arg(m_iChannelID));
103	}
104
105	// Return whether we're a valid channel...
106	return (m_iChannelID >= 0);
107	}
108
109
110	// Remove sampler channel.
111	bool qsamplerChannel::removeChannel (void)
112	{
113	if (client() == NULL)
114	return false;
115
116	// Are we an existing channel?
117	if (m_iChannelID >= 0) {
118	if (::lscp_remove_channel(client(), m_iChannelID) != LSCP_OK) {
119	appendMessagesClient("lscp_remove_channel");
120	appendMessagesError(QObject::tr("Could not remove channel.\n\nSorry."));
121	} else {
122	// Otherwise it's removed.
123	appendMessages(QObject::tr("Channel %1 removed.").arg(m_iChannelID));
124	m_iChannelID = -1;
125	}
126	}
127
128	// Return whether we've removed the channel...
129	return (m_iChannelID < 0);
130	}
131
132
133	// Channel-ID (aka Sammpler-Channel) accessors.
134	int qsamplerChannel::channelID (void)
135	{
136	return m_iChannelID;
137	}
138
139	void qsamplerChannel::setChannelID ( int iChannelID )
140	{
141	m_iChannelID = iChannelID;
142	}
143
144
145	// Readable channel name.
146	QString qsamplerChannel::channelName (void)
147	{
148	return (m_iChannelID < 0 ? QObject::tr("New Channel") : QObject::tr("Channel %1").arg(m_iChannelID));
149	}
150
151
152	// Engine name accessors.
153	QString& qsamplerChannel::engineName (void)
154	{
155	return m_sEngineName;
156	}
157
158	bool qsamplerChannel::loadEngine ( const QString& sEngineName )
159	{
160	if (client() == NULL \|\| m_iChannelID < 0)
161	return false;
162
163	if (::lscp_load_engine(client(), sEngineName.latin1(), m_iChannelID) != LSCP_OK) {
164	appendMessagesClient("lscp_load_engine");
165	return false;
166	}
167
168	m_sEngineName = sEngineName;
169	return true;
170	}
171
172
173	// Instrument name accessor.
174	QString& qsamplerChannel::instrumentName (void)
175	{
176	return m_sInstrumentName;
177	}
178
179	// Instrument filename accessor.
180	QString& qsamplerChannel::instrumentFile (void)
181	{
182	return m_sInstrumentFile;
183	}
184
185	// Instrument index accessor.
186	int qsamplerChannel::instrumentNr (void)
187	{
188	return m_iInstrumentNr;
189	}
190
191	// Instrument status accessor.
192	int qsamplerChannel::instrumentStatus (void)
193	{
194	return m_iInstrumentStatus;
195	}
196
197	// Instrument file loader.
198	bool qsamplerChannel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
199	{
200	if (client() == NULL \|\| m_iChannelID < 0)
201	return false;
202
203	if (::lscp_load_instrument_non_modal(client(), sInstrumentFile.latin1(), iInstrumentNr, m_iChannelID) != LSCP_OK) {
204	appendMessagesClient("lscp_load_instrument");
205	return false;
206	}
207
208	m_sInstrumentName = getInstrumentName(sInstrumentFile, iInstrumentNr, true);
209	m_sInstrumentFile = sInstrumentFile;
210	m_iInstrumentNr = iInstrumentNr;
211	m_iInstrumentStatus = 0;
212
213	return true;
214	}
215
216
217	// MIDI driver type accessors (DEPRECATED).
218	QString& qsamplerChannel::midiDriver (void)
219	{
220	return m_sMidiDriver;
221	}
222
223	bool qsamplerChannel::setMidiDriver ( const QString& sMidiDriver )
224	{
225	if (client() == NULL \|\| m_iChannelID < 0)
226	return false;
227
228	if (::lscp_set_channel_midi_type(client(), m_iChannelID, sMidiDriver.latin1()) != LSCP_OK) {
229	appendMessagesClient("lscp_set_channel_midi_type");
230	return false;
231	}
232
233	m_sMidiDriver = sMidiDriver;
234	return true;
235	}
236
237
238	// MIDI device accessors.
239	int qsamplerChannel::midiDevice (void)
240	{
241	return m_iMidiDevice;
242	}
243
244	bool qsamplerChannel::setMidiDevice ( int iMidiDevice )
245	{
246	if (client() == NULL \|\| m_iChannelID < 0)
247	return false;
248
249	if (::lscp_set_channel_midi_device(client(), m_iChannelID, iMidiDevice) != LSCP_OK) {
250	appendMessagesClient("lscp_set_channel_midi_device");
251	return false;
252	}
253
254	m_iMidiDevice = iMidiDevice;
255	return true;
256	}
257
258
259	// MIDI port number accessor.
260	int qsamplerChannel::midiPort (void)
261	{
262	return m_iMidiPort;
263	}
264
265	bool qsamplerChannel::setMidiPort ( int iMidiPort )
266	{
267	if (client() == NULL \|\| m_iChannelID < 0)
268	return false;
269
270	if (::lscp_set_channel_midi_port(client(), m_iChannelID, iMidiPort) != LSCP_OK) {
271	appendMessagesClient("lscp_set_channel_midi_port");
272	return false;
273	}
274
275	m_iMidiPort = iMidiPort;
276	return true;
277	}
278
279
280	// MIDI channel accessor.
281	int qsamplerChannel::midiChannel (void)
282	{
283	return m_iMidiChannel;
284	}
285
286	bool qsamplerChannel::setMidiChannel ( int iMidiChannel )
287	{
288	if (client() == NULL \|\| m_iChannelID < 0)
289	return false;
290
291	if (::lscp_set_channel_midi_channel(client(), m_iChannelID, iMidiChannel) != LSCP_OK) {
292	appendMessagesClient("lscp_set_channel_midi_channel");
293	return false;
294	}
295
296	m_iMidiChannel = iMidiChannel;
297	return true;
298	}
299
300
301	// Audio device accessor.
302	int qsamplerChannel::audioDevice (void)
303	{
304	return m_iAudioDevice;
305	}
306
307	bool qsamplerChannel::setAudioDevice ( int iAudioDevice )
308	{
309	if (client() == NULL \|\| m_iChannelID < 0)
310	return false;
311
312	if (::lscp_set_channel_audio_device(client(), m_iChannelID, iAudioDevice) != LSCP_OK) {
313	appendMessagesClient("lscp_set_channel_audio_device");
314	return false;
315	}
316
317	m_iAudioDevice = iAudioDevice;
318	return true;
319	}
320
321
322	// Audio driver type accessors (DEPRECATED).
323	QString& qsamplerChannel::audioDriver (void)
324	{
325	return m_sAudioDriver;
326	}
327
328	bool qsamplerChannel::setAudioDriver ( const QString& sAudioDriver )
329	{
330	if (client() == NULL \|\| m_iChannelID < 0)
331	return false;
332
333	if (::lscp_set_channel_audio_type(client(), m_iChannelID, sAudioDriver.latin1()) != LSCP_OK) {
334	appendMessagesClient("lscp_set_channel_audio_type");
335	return false;
336	}
337
338	m_sAudioDriver = sAudioDriver;
339	return true;
340	}
341
342
343	// Channel volume accessors.
344	float qsamplerChannel::volume (void)
345	{
346	return m_fVolume;
347	}
348
349	bool qsamplerChannel::setVolume ( float fVolume )
350	{
351	if (client() == NULL \|\| m_iChannelID < 0)
352	return false;
353
354	if (::lscp_set_channel_volume(client(), m_iChannelID, fVolume) != LSCP_OK) {
355	appendMessagesClient("lscp_set_channel_volume");
356	return false;
357	}
358
359	m_fVolume = fVolume;
360	return true;
361	}
362
363
364	// Istrument name remapper.
365	void qsamplerChannel::updateInstrumentName (void)
366	{
367	m_sInstrumentName = getInstrumentName(m_sInstrumentFile,
368	m_iInstrumentNr, (options() && options()->bInstrumentNames));
369	}
370
371
372	// Update whole channel info state.
373	bool qsamplerChannel::updateChannelInfo (void)
374	{
375	if (client() == NULL \|\| m_iChannelID < 0)
376	return false;
377
378	// Read channel information.
379	lscp_channel_info_t *pChannelInfo = ::lscp_get_channel_info(client(), m_iChannelID);
380	if (pChannelInfo == NULL) {
381	appendMessagesClient("lscp_get_channel_info");
382	appendMessagesError(QObject::tr("Could not get channel information.\n\nSorry."));
383	return false;
384	}
385
386	// First, check if intrument name has changed,
387	// taking care that instrument name lookup might be expensive,
388	// so we better make it only once and when really needed...
389	if ((m_sInstrumentFile != pChannelInfo->instrument_file) \|\|
390	(m_iInstrumentNr != pChannelInfo->instrument_nr)) {
391	m_sInstrumentFile = pChannelInfo->instrument_file;
392	m_iInstrumentNr = pChannelInfo->instrument_nr;
393	updateInstrumentName();
394	}
395	// Cache in other channel information.
396	m_sEngineName = pChannelInfo->engine_name;
397	m_iInstrumentStatus = pChannelInfo->instrument_status;
398	m_iMidiDevice = pChannelInfo->midi_device;
399	m_iMidiPort = pChannelInfo->midi_port;
400	m_iMidiChannel = pChannelInfo->midi_channel;
401	m_iAudioDevice = pChannelInfo->audio_device;
402	m_fVolume = pChannelInfo->volume;
403	// Some sanity checks.
404	if (m_sEngineName == "NONE")
405	m_sEngineName = QString::null;
406	if (m_sInstrumentFile == "NONE") {
407	m_sInstrumentFile = QString::null;
408	m_sInstrumentName = QString::null;
409	}
410
411	return true;
412	}
413
414
415	// Reset channel method.
416	bool qsamplerChannel::resetChannel (void)
417	{
418	if (client() == NULL \|\| m_iChannelID < 0)
419	return false;
420
421	if (::lscp_reset_channel(client(), m_iChannelID) != LSCP_OK) {
422	appendMessagesClient("lscp_reset_channel");
423	return false;
424	}
425
426	appendMessages(QObject::tr("Channel %1 reset.").arg(m_iChannelID));
427	return true;
428	}
429
430
431	// Channel setup dialog form.
432	bool qsamplerChannel::channelSetup ( QWidget *pParent )
433	{
434	bool bResult = false;
435
436	qsamplerChannelForm *pChannelForm = new qsamplerChannelForm(pParent);
437	if (pChannelForm) {
438	pChannelForm->setup(this);
439	bResult = pChannelForm->exec();
440	delete pChannelForm;
441	}
442
443	return bResult;
444	}
445
446
447	// Redirected messages output methods.
448	void qsamplerChannel::appendMessages( const QString& s )
449	{
450	if (m_pMainForm) m_pMainForm->appendMessages(s);
451	}
452
453	void qsamplerChannel::appendMessagesColor( const QString& s, const QString& c )
454	{
455	if (m_pMainForm) m_pMainForm->appendMessagesColor(s, c);
456	}
457
458	void qsamplerChannel::appendMessagesText( const QString& s )
459	{
460	if (m_pMainForm) m_pMainForm->appendMessagesText(s);
461	}
462
463	void qsamplerChannel::appendMessagesError( const QString& s )
464	{
465	if (m_pMainForm) m_pMainForm->appendMessagesError(s);
466	}
467
468	void qsamplerChannel::appendMessagesClient( const QString& s )
469	{
470	if (m_pMainForm) m_pMainForm->appendMessagesClient(s);
471	}
472
473
474	// Context menu event handler.
475	void qsamplerChannel::contextMenuEvent( QContextMenuEvent *pEvent )
476	{
477	if (m_pMainForm) m_pMainForm->contextMenuEvent(pEvent);
478	}
479
480
481	// Retrieve the instrument list of a instrument file (.gig).
482	QStringList qsamplerChannel::getInstrumentList( const QString& sInstrumentFile,
483	bool bInstrumentNames )
484	{
485	QFileInfo fileinfo(sInstrumentFile);
486	QString sInstrumentName = fileinfo.fileName();
487	QStringList instlist;
488
489	if (fileinfo.exists()) {
490	#ifdef CONFIG_LIBGIG
491	if (bInstrumentNames) {
492	RIFF::File *pRiff = new RIFF::File(sInstrumentFile);
493	gig::File *pGig = new gig::File(pRiff);
494	gig::Instrument *pInstrument = pGig->GetFirstInstrument();
495	while (pInstrument) {
496	instlist.append((pInstrument->pInfo)->Name.c_str());
497	pInstrument = pGig->GetNextInstrument();
498	}
499	delete pGig;
500	delete pRiff;
501	}
502	else
503	#endif
504	for (int iInstrumentNr = 0; iInstrumentNr < QSAMPLER_INSTRUMENT_MAX; iInstrumentNr++)
505	instlist.append(sInstrumentName + " [" + QString::number(iInstrumentNr) + "]");
506	}
507	else instlist.append(sInstrumentName);
508
509	return instlist;
510	}
511
512
513	// Retrieve the spacific instrument name of a instrument file (.gig), given its index.
514	QString qsamplerChannel::getInstrumentName( const QString& sInstrumentFile,
515	int iInstrumentNr, bool bInstrumentNames )
516	{
517	QFileInfo fileinfo(sInstrumentFile);
518	QString sInstrumentName = fileinfo.fileName();
519
520	if (fileinfo.exists()) {
521	#ifdef CONFIG_LIBGIG
522	if (bInstrumentNames) {
523	RIFF::File *pRiff = new RIFF::File(sInstrumentFile);
524	gig::File *pGig = new gig::File(pRiff);
525	int iIndex = 0;
526	gig::Instrument *pInstrument = pGig->GetFirstInstrument();
527	while (pInstrument) {
528	if (iIndex == iInstrumentNr) {
529	sInstrumentName = (pInstrument->pInfo)->Name.c_str();
530	break;
531	}
532	iIndex++;
533	pInstrument = pGig->GetNextInstrument();
534	}
535	delete pGig;
536	delete pRiff;
537	}
538	else
539	#endif
540	sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
541	}
542
543	return sInstrumentName;
544	}
545
546
547	// end of qsamplerChannel.cpp