/[svn]/qsampler/trunk/src/qsamplerChannel.cpp
ViewVC logotype

Annotation of /qsampler/trunk/src/qsamplerChannel.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 371 - (hide annotations) (download)
Fri Feb 11 15:36:06 2005 UTC (15 years, 9 months ago) by capela
File size: 14311 byte(s)
Instrument names display mode update on all channels.

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     // m_sEngineName = QObject::tr("(No engine)");
49 capela 344 // m_sInstrumentName = QObject::tr("(No instrument)");
50     // 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    
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 capela 344 // Instrument name accessor.
174     QString& qsamplerChannel::instrumentName (void)
175     {
176     return m_sInstrumentName;
177     }
178    
179 capela 264 // 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 capela 295 if (client() == NULL || m_iChannelID < 0)
201 capela 264 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 capela 344 m_sInstrumentName = getInstrumentName(sInstrumentFile, iInstrumentNr, true);
209 capela 264 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 capela 295 if (client() == NULL || m_iChannelID < 0)
226 capela 264 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 capela 295 if (client() == NULL || m_iChannelID < 0)
247 capela 264 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 capela 295 if (client() == NULL || m_iChannelID < 0)
268 capela 264 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 capela 295 if (client() == NULL || m_iChannelID < 0)
289 capela 264 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 capela 295 if (client() == NULL || m_iChannelID < 0)
310 capela 264 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 capela 295 if (client() == NULL || m_iChannelID < 0)
331 capela 264 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 capela 295 if (client() == NULL || m_iChannelID < 0)
352 capela 264 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 capela 371 // 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 capela 264 // Update whole channel info state.
373 capela 295 bool qsamplerChannel::updateChannelInfo (void)
374 capela 264 {
375 capela 295 if (client() == NULL || m_iChannelID < 0)
376     return false;
377 capela 264
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 capela 295 return false;
384 capela 264 }
385 capela 295
386 capela 371 // 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 capela 344 }
395     // Cache in other channel information.
396 capela 295 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 capela 344 if (m_sInstrumentFile == "NONE") {
407 capela 295 m_sInstrumentFile = QString::null;
408 capela 344 m_sInstrumentName = QString::null;
409     }
410 capela 295
411     return true;
412 capela 264 }
413    
414    
415     // Reset channel method.
416 capela 295 bool qsamplerChannel::resetChannel (void)
417 capela 264 {
418 capela 295 if (client() == NULL || m_iChannelID < 0)
419     return false;
420 capela 264
421 capela 295 if (::lscp_reset_channel(client(), m_iChannelID) != LSCP_OK) {
422 capela 264 appendMessagesClient("lscp_reset_channel");
423 capela 295 return false;
424     }
425    
426     appendMessages(QObject::tr("Channel %1 reset.").arg(m_iChannelID));
427     return true;
428 capela 264 }
429    
430    
431 capela 303 // 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 capela 264 // Redirected messages output methods.
448     void qsamplerChannel::appendMessages( const QString& s )
449     {
450 capela 303 if (m_pMainForm) m_pMainForm->appendMessages(s);
451 capela 264 }
452    
453     void qsamplerChannel::appendMessagesColor( const QString& s, const QString& c )
454     {
455 capela 303 if (m_pMainForm) m_pMainForm->appendMessagesColor(s, c);
456 capela 264 }
457    
458     void qsamplerChannel::appendMessagesText( const QString& s )
459     {
460 capela 303 if (m_pMainForm) m_pMainForm->appendMessagesText(s);
461 capela 264 }
462    
463     void qsamplerChannel::appendMessagesError( const QString& s )
464     {
465 capela 303 if (m_pMainForm) m_pMainForm->appendMessagesError(s);
466 capela 264 }
467    
468     void qsamplerChannel::appendMessagesClient( const QString& s )
469     {
470 capela 303 if (m_pMainForm) m_pMainForm->appendMessagesClient(s);
471 capela 264 }
472    
473    
474 capela 303 // Context menu event handler.
475     void qsamplerChannel::contextMenuEvent( QContextMenuEvent *pEvent )
476     {
477     if (m_pMainForm) m_pMainForm->contextMenuEvent(pEvent);
478     }
479    
480    
481 capela 299 // Retrieve the instrument list of a instrument file (.gig).
482 capela 344 QStringList qsamplerChannel::getInstrumentList( const QString& sInstrumentFile,
483     bool bInstrumentNames )
484 capela 299 {
485     QFileInfo fileinfo(sInstrumentFile);
486     QString sInstrumentName = fileinfo.fileName();
487     QStringList instlist;
488    
489     if (fileinfo.exists()) {
490     #ifdef CONFIG_LIBGIG
491 capela 344 if (bInstrumentNames) {
492 capela 341 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 capela 342 #endif
504 capela 299 for (int iInstrumentNr = 0; iInstrumentNr < QSAMPLER_INSTRUMENT_MAX; iInstrumentNr++)
505     instlist.append(sInstrumentName + " [" + QString::number(iInstrumentNr) + "]");
506     }
507     else instlist.append(sInstrumentName);
508 capela 306
509 capela 299 return instlist;
510     }
511    
512    
513     // Retrieve the spacific instrument name of a instrument file (.gig), given its index.
514 capela 344 QString qsamplerChannel::getInstrumentName( const QString& sInstrumentFile,
515     int iInstrumentNr, bool bInstrumentNames )
516 capela 299 {
517     QFileInfo fileinfo(sInstrumentFile);
518     QString sInstrumentName = fileinfo.fileName();
519    
520     if (fileinfo.exists()) {
521     #ifdef CONFIG_LIBGIG
522 capela 344 if (bInstrumentNames) {
523 capela 341 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 capela 342 #endif
540 capela 299 sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
541     }
542    
543     return sInstrumentName;
544     }
545    
546    
547 capela 264 // end of qsamplerChannel.cpp

  ViewVC Help
Powered by ViewVC