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       = noEngineName();
//  m_sInstrumentName   = noInstrumentName();
//  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 (m_iInstrumentStatus == 100 && m_sEngineName == sEngineName)
            return true;
            
    if (::lscp_load_engine(client(), sEngineName.latin1(), m_iChannelID) != LSCP_OK) {
        appendMessagesClient("lscp_load_engine");
        return false;
    }

    m_sEngineName = sEngineName;
    return true;
}


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

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

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

// 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 (!isInstrumentFile(sInstrumentFile))
            return false;
        if (m_iInstrumentStatus == 100 && m_sInstrumentFile == sInstrumentFile && m_iInstrumentNr == iInstrumentNr)
            return true;

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

    return setInstrument(sInstrumentFile, iInstrumentNr);
}


// Special instrument file/name/number settler.
bool qsamplerChannel::setInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
{
    m_sInstrumentFile = sInstrumentFile;
    m_iInstrumentNr = iInstrumentNr;
#ifdef CONFIG_INSTRUMENT_NAME
    m_sInstrumentName = QString::null;  // We'll get it, maybe later, on channel_info...
#else
    m_sInstrumentName = getInstrumentName(sInstrumentFile, iInstrumentNr, true);
#endif
    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 (m_iInstrumentStatus == 100 && m_sMidiDriver == sMidiDriver)
            return true;

    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 (m_iInstrumentStatus == 100 && m_iMidiDevice == iMidiDevice)
            return true;

    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 (m_iInstrumentStatus == 100 && m_iMidiPort == iMidiPort)
            return true;

    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 (m_iInstrumentStatus == 100 && m_iMidiChannel == iMidiChannel)
            return true;

    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 (m_iInstrumentStatus == 100 && m_iAudioDevice == iAudioDevice)
            return true;

    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 (m_iInstrumentStatus == 100 && m_sAudioDriver == sAudioDriver)
            return true;

    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 (m_iInstrumentStatus == 100 && m_fVolume == fVolume)
            return true;

    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)
{
#ifndef CONFIG_INSTRUMENT_NAME
        m_sInstrumentName = getInstrumentName(m_sInstrumentFile,
                m_iInstrumentNr, (options() && options()->bInstrumentNames));
#endif
}


// 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;
    }

#ifdef CONFIG_INSTRUMENT_NAME
        // We got all actual instrument datum...
        m_sInstrumentFile = pChannelInfo->instrument_file;
        m_iInstrumentNr   = pChannelInfo->instrument_nr;
        m_sInstrumentName = pChannelInfo->instrument_name;
#else
        // 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();
        }
#endif
    // 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::channelReset (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);
}


// FIXME: Check whether a given file is an instrument file.
bool qsamplerChannel::isInstrumentFile ( const QString& sInstrumentFile )
{
        bool bResult = false;

        QFile file(sInstrumentFile);
        if (file.open(IO_ReadOnly)) {
                char achHeader[4];
                if (file.readBlock(achHeader, 4)) {
                        bResult = (achHeader[0] == 'R'
                                        && achHeader[1] == 'I'
                                        && achHeader[2] == 'F'
                                        && achHeader[3] == 'F');
                }
                file.close();
        }

        return bResult;
}


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

    if (isInstrumentFile(sInstrumentFile)) {
#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(noInstrumentName());

    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 )
{
    QString sInstrumentName;

    if (isInstrumentFile(sInstrumentFile)) {
                sInstrumentName = QFileInfo(sInstrumentFile).fileName();
#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) + "]";
    }
    else sInstrumentName = noInstrumentName();

    return sInstrumentName;
}


// Common invalid name-helpers.
QString qsamplerChannel::noEngineName (void)
{
        return QObject::tr("(No engine)");
}

QString qsamplerChannel::noInstrumentName (void)
{
        return QObject::tr("(No instrument)");
}


// end of qsamplerChannel.cpp
1	capela	264	// qsamplerChannel.cpp
2			//
3			/****************************************************************************
4	capela	341	Copyright (C) 2003-2005, rncbc aka Rui Nuno Capela. All rights reserved.
5	capela	264
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	capela	303	#include "qsamplerChannelForm.h"
26	capela	264
27			#include "config.h"
28
29	capela	299	#include <qfileinfo.h>
30	capela	264
31	capela	299	#ifdef CONFIG_LIBGIG
32			#include "gig.h"
33			#endif
34
35	capela	343	#define QSAMPLER_INSTRUMENT_MAX 8
36	capela	299
37	capela	343
38	capela	264	//-------------------------------------------------------------------------
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	capela	388	// m_sEngineName = noEngineName();
49			// m_sInstrumentName = noInstrumentName();
50	capela	344	// m_sInstrumentFile = m_sInstrumentName;
51	capela	264	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	capela	295	// 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	capela	264	// 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	capela	295	// 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	capela	264	// Engine name accessors.
153			QString& qsamplerChannel::engineName (void)
154			{
155			return m_sEngineName;
156			}
157
158			bool qsamplerChannel::loadEngine ( const QString& sEngineName )
159			{
160	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
161	capela	264	return false;
162	capela	400	if (m_iInstrumentStatus == 100 && m_sEngineName == sEngineName)
163			return true;
164
165	capela	264	if (::lscp_load_engine(client(), sEngineName.latin1(), m_iChannelID) != LSCP_OK) {
166			appendMessagesClient("lscp_load_engine");
167			return false;
168			}
169
170			m_sEngineName = sEngineName;
171			return true;
172			}
173
174
175			// Instrument filename accessor.
176			QString& qsamplerChannel::instrumentFile (void)
177			{
178			return m_sInstrumentFile;
179			}
180
181			// Instrument index accessor.
182			int qsamplerChannel::instrumentNr (void)
183			{
184			return m_iInstrumentNr;
185			}
186
187	capela	382	// Instrument name accessor.
188			QString& qsamplerChannel::instrumentName (void)
189			{
190			return m_sInstrumentName;
191			}
192
193	capela	264	// Instrument status accessor.
194			int qsamplerChannel::instrumentStatus (void)
195			{
196			return m_iInstrumentStatus;
197			}
198
199			// Instrument file loader.
200			bool qsamplerChannel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
201			{
202	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
203	capela	264	return false;
204	capela	388	if (!isInstrumentFile(sInstrumentFile))
205			return false;
206	capela	400	if (m_iInstrumentStatus == 100 && m_sInstrumentFile == sInstrumentFile && m_iInstrumentNr == iInstrumentNr)
207			return true;
208	capela	264
209			if (::lscp_load_instrument_non_modal(client(), sInstrumentFile.latin1(), iInstrumentNr, m_iChannelID) != LSCP_OK) {
210			appendMessagesClient("lscp_load_instrument");
211			return false;
212			}
213
214	capela	388	return setInstrument(sInstrumentFile, iInstrumentNr);
215			}
216
217
218			// Special instrument file/name/number settler.
219			bool qsamplerChannel::setInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
220			{
221	capela	264	m_sInstrumentFile = sInstrumentFile;
222			m_iInstrumentNr = iInstrumentNr;
223	capela	382	#ifdef CONFIG_INSTRUMENT_NAME
224	capela	388	m_sInstrumentName = QString::null; // We'll get it, maybe later, on channel_info...
225	capela	382	#else
226			m_sInstrumentName = getInstrumentName(sInstrumentFile, iInstrumentNr, true);
227			#endif
228	capela	264	m_iInstrumentStatus = 0;
229
230	capela	388	return true;
231	capela	264	}
232
233
234			// MIDI driver type accessors (DEPRECATED).
235			QString& qsamplerChannel::midiDriver (void)
236			{
237			return m_sMidiDriver;
238			}
239
240			bool qsamplerChannel::setMidiDriver ( const QString& sMidiDriver )
241			{
242	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
243	capela	264	return false;
244	capela	400	if (m_iInstrumentStatus == 100 && m_sMidiDriver == sMidiDriver)
245			return true;
246	capela	264
247			if (::lscp_set_channel_midi_type(client(), m_iChannelID, sMidiDriver.latin1()) != LSCP_OK) {
248			appendMessagesClient("lscp_set_channel_midi_type");
249			return false;
250			}
251
252			m_sMidiDriver = sMidiDriver;
253			return true;
254			}
255
256
257			// MIDI device accessors.
258			int qsamplerChannel::midiDevice (void)
259			{
260			return m_iMidiDevice;
261			}
262
263			bool qsamplerChannel::setMidiDevice ( int iMidiDevice )
264			{
265	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
266	capela	264	return false;
267	capela	400	if (m_iInstrumentStatus == 100 && m_iMidiDevice == iMidiDevice)
268			return true;
269	capela	264
270			if (::lscp_set_channel_midi_device(client(), m_iChannelID, iMidiDevice) != LSCP_OK) {
271			appendMessagesClient("lscp_set_channel_midi_device");
272			return false;
273			}
274
275			m_iMidiDevice = iMidiDevice;
276			return true;
277			}
278
279
280			// MIDI port number accessor.
281			int qsamplerChannel::midiPort (void)
282			{
283			return m_iMidiPort;
284			}
285
286			bool qsamplerChannel::setMidiPort ( int iMidiPort )
287			{
288	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
289	capela	264	return false;
290	capela	400	if (m_iInstrumentStatus == 100 && m_iMidiPort == iMidiPort)
291			return true;
292	capela	264
293			if (::lscp_set_channel_midi_port(client(), m_iChannelID, iMidiPort) != LSCP_OK) {
294			appendMessagesClient("lscp_set_channel_midi_port");
295			return false;
296			}
297
298			m_iMidiPort = iMidiPort;
299			return true;
300			}
301
302
303			// MIDI channel accessor.
304			int qsamplerChannel::midiChannel (void)
305			{
306			return m_iMidiChannel;
307			}
308
309			bool qsamplerChannel::setMidiChannel ( int iMidiChannel )
310			{
311	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
312	capela	264	return false;
313	capela	400	if (m_iInstrumentStatus == 100 && m_iMidiChannel == iMidiChannel)
314			return true;
315	capela	264
316			if (::lscp_set_channel_midi_channel(client(), m_iChannelID, iMidiChannel) != LSCP_OK) {
317			appendMessagesClient("lscp_set_channel_midi_channel");
318			return false;
319			}
320
321			m_iMidiChannel = iMidiChannel;
322			return true;
323			}
324
325
326			// Audio device accessor.
327			int qsamplerChannel::audioDevice (void)
328			{
329			return m_iAudioDevice;
330			}
331
332			bool qsamplerChannel::setAudioDevice ( int iAudioDevice )
333			{
334	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
335	capela	264	return false;
336	capela	400	if (m_iInstrumentStatus == 100 && m_iAudioDevice == iAudioDevice)
337			return true;
338	capela	264
339			if (::lscp_set_channel_audio_device(client(), m_iChannelID, iAudioDevice) != LSCP_OK) {
340			appendMessagesClient("lscp_set_channel_audio_device");
341			return false;
342			}
343
344			m_iAudioDevice = iAudioDevice;
345			return true;
346			}
347
348
349			// Audio driver type accessors (DEPRECATED).
350			QString& qsamplerChannel::audioDriver (void)
351			{
352			return m_sAudioDriver;
353			}
354
355			bool qsamplerChannel::setAudioDriver ( const QString& sAudioDriver )
356			{
357	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
358	capela	264	return false;
359	capela	400	if (m_iInstrumentStatus == 100 && m_sAudioDriver == sAudioDriver)
360			return true;
361	capela	264
362			if (::lscp_set_channel_audio_type(client(), m_iChannelID, sAudioDriver.latin1()) != LSCP_OK) {
363			appendMessagesClient("lscp_set_channel_audio_type");
364			return false;
365			}
366
367			m_sAudioDriver = sAudioDriver;
368			return true;
369			}
370
371
372			// Channel volume accessors.
373			float qsamplerChannel::volume (void)
374			{
375			return m_fVolume;
376			}
377
378			bool qsamplerChannel::setVolume ( float fVolume )
379			{
380	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
381	capela	264	return false;
382	capela	400	if (m_iInstrumentStatus == 100 && m_fVolume == fVolume)
383			return true;
384	capela	264
385			if (::lscp_set_channel_volume(client(), m_iChannelID, fVolume) != LSCP_OK) {
386			appendMessagesClient("lscp_set_channel_volume");
387			return false;
388			}
389
390			m_fVolume = fVolume;
391			return true;
392			}
393
394
395	capela	371	// Istrument name remapper.
396			void qsamplerChannel::updateInstrumentName (void)
397			{
398	capela	382	#ifndef CONFIG_INSTRUMENT_NAME
399	capela	371	m_sInstrumentName = getInstrumentName(m_sInstrumentFile,
400			m_iInstrumentNr, (options() && options()->bInstrumentNames));
401	capela	382	#endif
402	capela	371	}
403
404
405	capela	264	// Update whole channel info state.
406	capela	295	bool qsamplerChannel::updateChannelInfo (void)
407	capela	264	{
408	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
409			return false;
410	capela	264
411			// Read channel information.
412			lscp_channel_info_t *pChannelInfo = ::lscp_get_channel_info(client(), m_iChannelID);
413			if (pChannelInfo == NULL) {
414			appendMessagesClient("lscp_get_channel_info");
415			appendMessagesError(QObject::tr("Could not get channel information.\n\nSorry."));
416	capela	295	return false;
417	capela	264	}
418	capela	295
419	capela	382	#ifdef CONFIG_INSTRUMENT_NAME
420			// We got all actual instrument datum...
421			m_sInstrumentFile = pChannelInfo->instrument_file;
422			m_iInstrumentNr = pChannelInfo->instrument_nr;
423			m_sInstrumentName = pChannelInfo->instrument_name;
424			#else
425	capela	371	// First, check if intrument name has changed,
426			// taking care that instrument name lookup might be expensive,
427			// so we better make it only once and when really needed...
428			if ((m_sInstrumentFile != pChannelInfo->instrument_file) \|\|
429			(m_iInstrumentNr != pChannelInfo->instrument_nr)) {
430			m_sInstrumentFile = pChannelInfo->instrument_file;
431			m_iInstrumentNr = pChannelInfo->instrument_nr;
432			updateInstrumentName();
433	capela	344	}
434	capela	382	#endif
435	capela	344	// Cache in other channel information.
436	capela	295	m_sEngineName = pChannelInfo->engine_name;
437			m_iInstrumentStatus = pChannelInfo->instrument_status;
438			m_iMidiDevice = pChannelInfo->midi_device;
439			m_iMidiPort = pChannelInfo->midi_port;
440			m_iMidiChannel = pChannelInfo->midi_channel;
441			m_iAudioDevice = pChannelInfo->audio_device;
442			m_fVolume = pChannelInfo->volume;
443			// Some sanity checks.
444			if (m_sEngineName == "NONE")
445			m_sEngineName = QString::null;
446	capela	344	if (m_sInstrumentFile == "NONE") {
447	capela	295	m_sInstrumentFile = QString::null;
448	capela	344	m_sInstrumentName = QString::null;
449			}
450	capela	295
451			return true;
452	capela	264	}
453
454
455			// Reset channel method.
456	capela	400	bool qsamplerChannel::channelReset (void)
457	capela	264	{
458	capela	295	if (client() == NULL \|\| m_iChannelID < 0)
459			return false;
460	capela	264
461	capela	295	if (::lscp_reset_channel(client(), m_iChannelID) != LSCP_OK) {
462	capela	264	appendMessagesClient("lscp_reset_channel");
463	capela	295	return false;
464			}
465
466			appendMessages(QObject::tr("Channel %1 reset.").arg(m_iChannelID));
467			return true;
468	capela	264	}
469
470
471	capela	303	// Channel setup dialog form.
472			bool qsamplerChannel::channelSetup ( QWidget *pParent )
473			{
474			bool bResult = false;
475
476			qsamplerChannelForm *pChannelForm = new qsamplerChannelForm(pParent);
477			if (pChannelForm) {
478			pChannelForm->setup(this);
479			bResult = pChannelForm->exec();
480			delete pChannelForm;
481			}
482
483			return bResult;
484			}
485
486
487	capela	264	// Redirected messages output methods.
488			void qsamplerChannel::appendMessages( const QString& s )
489			{
490	capela	303	if (m_pMainForm) m_pMainForm->appendMessages(s);
491	capela	264	}
492
493			void qsamplerChannel::appendMessagesColor( const QString& s, const QString& c )
494			{
495	capela	303	if (m_pMainForm) m_pMainForm->appendMessagesColor(s, c);
496	capela	264	}
497
498			void qsamplerChannel::appendMessagesText( const QString& s )
499			{
500	capela	303	if (m_pMainForm) m_pMainForm->appendMessagesText(s);
501	capela	264	}
502
503			void qsamplerChannel::appendMessagesError( const QString& s )
504			{
505	capela	303	if (m_pMainForm) m_pMainForm->appendMessagesError(s);
506	capela	264	}
507
508			void qsamplerChannel::appendMessagesClient( const QString& s )
509			{
510	capela	303	if (m_pMainForm) m_pMainForm->appendMessagesClient(s);
511	capela	264	}
512
513
514	capela	303	// Context menu event handler.
515			void qsamplerChannel::contextMenuEvent( QContextMenuEvent *pEvent )
516			{
517			if (m_pMainForm) m_pMainForm->contextMenuEvent(pEvent);
518			}
519
520
521	capela	388	// FIXME: Check whether a given file is an instrument file.
522			bool qsamplerChannel::isInstrumentFile ( const QString& sInstrumentFile )
523			{
524			bool bResult = false;
525
526			QFile file(sInstrumentFile);
527			if (file.open(IO_ReadOnly)) {
528			char achHeader[4];
529			if (file.readBlock(achHeader, 4)) {
530			bResult = (achHeader[0] == 'R'
531			&& achHeader[1] == 'I'
532			&& achHeader[2] == 'F'
533			&& achHeader[3] == 'F');
534			}
535			file.close();
536			}
537
538			return bResult;
539			}
540
541
542	capela	299	// Retrieve the instrument list of a instrument file (.gig).
543	capela	344	QStringList qsamplerChannel::getInstrumentList( const QString& sInstrumentFile,
544			bool bInstrumentNames )
545	capela	299	{
546	capela	388	QString sInstrumentName = QFileInfo(sInstrumentFile).fileName();
547	capela	299	QStringList instlist;
548
549	capela	388	if (isInstrumentFile(sInstrumentFile)) {
550	capela	299	#ifdef CONFIG_LIBGIG
551	capela	344	if (bInstrumentNames) {
552	capela	341	RIFF::File *pRiff = new RIFF::File(sInstrumentFile);
553			gig::File *pGig = new gig::File(pRiff);
554			gig::Instrument *pInstrument = pGig->GetFirstInstrument();
555			while (pInstrument) {
556			instlist.append((pInstrument->pInfo)->Name.c_str());
557			pInstrument = pGig->GetNextInstrument();
558			}
559			delete pGig;
560			delete pRiff;
561			}
562			else
563	capela	342	#endif
564	capela	299	for (int iInstrumentNr = 0; iInstrumentNr < QSAMPLER_INSTRUMENT_MAX; iInstrumentNr++)
565			instlist.append(sInstrumentName + " [" + QString::number(iInstrumentNr) + "]");
566			}
567	capela	388	else instlist.append(noInstrumentName());
568	capela	306
569	capela	299	return instlist;
570			}
571
572
573			// Retrieve the spacific instrument name of a instrument file (.gig), given its index.
574	capela	344	QString qsamplerChannel::getInstrumentName( const QString& sInstrumentFile,
575			int iInstrumentNr, bool bInstrumentNames )
576	capela	299	{
577	capela	388	QString sInstrumentName;
578	capela	299
579	capela	388	if (isInstrumentFile(sInstrumentFile)) {
580			sInstrumentName = QFileInfo(sInstrumentFile).fileName();
581	capela	299	#ifdef CONFIG_LIBGIG
582	capela	344	if (bInstrumentNames) {
583	capela	341	RIFF::File *pRiff = new RIFF::File(sInstrumentFile);
584			gig::File *pGig = new gig::File(pRiff);
585			int iIndex = 0;
586			gig::Instrument *pInstrument = pGig->GetFirstInstrument();
587			while (pInstrument) {
588			if (iIndex == iInstrumentNr) {
589			sInstrumentName = (pInstrument->pInfo)->Name.c_str();
590			break;
591			}
592			iIndex++;
593			pInstrument = pGig->GetNextInstrument();
594			}
595			delete pGig;
596			delete pRiff;
597			}
598			else
599	capela	342	#endif
600	capela	299	sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
601			}
602	capela	388	else sInstrumentName = noInstrumentName();
603	capela	299
604			return sInstrumentName;
605			}
606
607
608	capela	388	// Common invalid name-helpers.
609			QString qsamplerChannel::noEngineName (void)
610			{
611			return QObject::tr("(No engine)");
612			}
613
614			QString qsamplerChannel::noInstrumentName (void)
615			{
616			return QObject::tr("(No instrument)");
617			}
618
619
620	capela	264	// end of qsamplerChannel.cpp