← Back to branch summary

~ubuntu-branches/ubuntu/quantal/muse/quantal

« back to all changes in this revision

Viewing changes to minstrument.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Kobras
  • Date: 2002-04-23 17:28:23 UTC
  • Revision ID: james.westby@ubuntu.com-20020423172823-w8yplzr81a759xa3
Tags: upstream-0.5.2
Import upstream version 0.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
minstrument.cpp
 
1
//=========================================================
 
2
//  MusE
 
3
//  Linux Music Editor
 
4
//  $Id: minstrument.cpp,v 1.2 2002/02/07 08:14:48 muse Exp $
 
5
//
 
6
//  (C) Copyright 2000 Werner Schweer (ws@seh.de)
 
7
//=========================================================
 
8
 
 
9
#include "minstrument.h"
 
10
#include "midiport.h"
 
11
#include "progname.h"
 
12
#include <qpopupmenu.h>
 
13
#include "globals.h"
 
14
#include "progname.h"
 
15
#include "xml.h"
 
16
#include "event.h"
 
17
 
 
18
#include <stdio.h>
 
19
 
 
20
MidiInstrumentList midiInstruments;
 
21
MidiInstrument* genericMidiInstrument;
 
22
 
 
23
//---------------------------------------------------------
 
24
//   initMidiInstruments
 
25
//---------------------------------------------------------
 
26
 
 
27
void initMidiInstruments()
 
28
      {
 
29
      genericMidiInstrument = new MidiInstrument("generic midi");
 
30
      midiInstruments.push_back(genericMidiInstrument);
 
31
      midiInstruments.push_back(new MidiGMInstrument("generic GM"));
 
32
      midiInstruments.push_back(new MidiGSInstrument("generic GS"));
 
33
      midiInstruments.push_back(new MidiXGInstrument("generic XG"));
 
34
      midiInstruments.push_back(new MidiP50mInstrument("Yamaha P50m"));
 
35
      midiInstruments.push_back(new MidiNS5RInstrument("Korg NS5R"));
 
36
      }
 
37
 
 
38
//---------------------------------------------------------
 
39
//   registerMidiInstrument
 
40
//---------------------------------------------------------
 
41
 
 
42
MidiInstrument* registerMidiInstrument(const QString& name)
 
43
      {
 
44
      for (iMidiInstrument i = midiInstruments.begin();
 
45
         i != midiInstruments.end(); ++i) {
 
46
            if ((*i)->iname() == name)
 
47
                  return *i;
 
48
            }
 
49
      return genericMidiInstrument;
 
50
      }
 
51
 
 
52
//---------------------------------------------------------
 
53
//   removeMidiInstrument
 
54
//---------------------------------------------------------
 
55
 
 
56
void removeMidiInstrument(const QString& name)
 
57
      {
 
58
      for (iMidiInstrument i = midiInstruments.begin();
 
59
         i != midiInstruments.end(); ++i) {
 
60
            printf("remove Instrument %s\n", name.latin1());
 
61
            midiInstruments.erase(i);
 
62
            return;
 
63
            }
 
64
      }
 
65
 
 
66
      EventList* _midiInit;
 
67
      EventList* _midiState;
 
68
 
 
69
//---------------------------------------------------------
 
70
//   MidiInstrument
 
71
//---------------------------------------------------------
 
72
 
 
73
MidiInstrument::MidiInstrument()
 
74
      {
 
75
      _midiInit = new EventList();
 
76
      _midiState = new EventList();
 
77
      }
 
78
 
 
79
//---------------------------------------------------------
 
80
//   MidiInstrument
 
81
//---------------------------------------------------------
 
82
 
 
83
MidiInstrument::MidiInstrument(const QString& txt)
 
84
      {
 
85
      _name = txt;
 
86
      _midiInit = new EventList();
 
87
      _midiState = new EventList();
 
88
      }
 
89
 
 
90
//---------------------------------------------------------
 
91
//   MidiInstrument
 
92
//---------------------------------------------------------
 
93
 
 
94
MidiInstrument::~MidiInstrument()
 
95
      {
 
96
      delete _midiInit;
 
97
      delete _midiState;
 
98
      }
 
99
 
 
100
//---------------------------------------------------------
 
101
//   getPatchName
 
102
//---------------------------------------------------------
 
103
 
 
104
const char* MidiInstrument::getPatchName(int, int, int, int, MType)
 
105
      {
 
106
      return "???";
 
107
      }
 
108
 
 
109
//---------------------------------------------------------
 
110
//   reset
 
111
//---------------------------------------------------------
 
112
 
 
113
void MidiGMInstrument::reset(int port, MType)
 
114
      {
 
115
      midiPorts[port].gmOn();
 
116
      }
 
117
 
 
118
//---------------------------------------------------------
 
119
//   getPatchName
 
120
//---------------------------------------------------------
 
121
 
 
122
const char* MidiGMInstrument::getPatchName(int channel,
 
123
  int, int, int prog, MType)
 
124
      {
 
125
      return getPatch(channel, 0, 0, prog, MT_GM);
 
126
      }
 
127
 
 
128
void MidiGMInstrument::populatePatchPopup(QPopupMenu* menu, int, MType)
 
129
      {
 
130
      menu->clear();
 
131
      int mask = 1;
 
132
      for (int i = 0; i < PROG_GROUPS; ++i) {
 
133
            QPopupMenu* pm = new QPopupMenu(menu);
 
134
            pm->setFont(font0);
 
135
            const MidiPatch* mp = patchGroups[i];
 
136
            int k = 0;
 
137
            while (mp->name) {
 
138
                  if (mp->typ & mask) {
 
139
                        int id = 0xffff00 + mp->prog;
 
140
                        pm->insertItem(mp->name, id);
 
141
                        }
 
142
                  ++k;
 
143
                  ++mp;
 
144
                  }
 
145
            menu->insertItem(gmGroups[i], pm);
 
146
            }
 
147
      }
 
148
 
 
149
//---------------------------------------------------------
 
150
//   reset
 
151
//---------------------------------------------------------
 
152
 
 
153
void MidiGSInstrument::reset(int port, MType type)
 
154
      {
 
155
      if (type == MT_GM)
 
156
            midiPorts[port].gmOn();
 
157
      else
 
158
            midiPorts[port].gsOn();
 
159
      }
 
160
 
 
161
//---------------------------------------------------------
 
162
//   getPatchName
 
163
//---------------------------------------------------------
 
164
 
 
165
const char* MidiGSInstrument::getPatchName(int channel,
 
166
  int hbank, int lbank, int prog, MType)
 
167
      {
 
168
      return getPatch(channel, hbank, lbank, prog, MT_GS);
 
169
      }
 
170
 
 
171
void MidiGSInstrument::populatePatchPopup(QPopupMenu* menu, int, MType songType)
 
172
      {
 
173
      menu->clear();
 
174
      int mask = 0;
 
175
      switch(songType) {
 
176
            case MT_GS: mask = 2; break;
 
177
            case MT_GM:
 
178
            case MT_XG:
 
179
            case MT_UNKNOWN:  mask = 1; break;
 
180
            }
 
181
      for (int i = 0; i < PROG_GROUPS; ++i) {
 
182
            QPopupMenu* pm = new QPopupMenu(menu);
 
183
            pm->setFont(font0);
 
184
            const MidiPatch* mp = patchGroups[i];
 
185
            int k = 0;
 
186
            while (mp->name) {
 
187
                  if (mp->typ & mask) {
 
188
                        int id = (mp->hbank<<16) + (mp->lbank<<8) + mp->prog;
 
189
                        pm->insertItem(mp->name, id);
 
190
                        }
 
191
                  ++k;
 
192
                  ++mp;
 
193
                  }
 
194
            menu->insertItem(gmGroups[i], pm);
 
195
            }
 
196
      }
 
197
 
 
198
//---------------------------------------------------------
 
199
//   reset
 
200
//---------------------------------------------------------
 
201
 
 
202
void MidiXGInstrument::reset(int port, MType)
 
203
      {
 
204
      midiPorts[port].xgOn();
 
205
      }
 
206
 
 
207
//---------------------------------------------------------
 
208
//   getPatchName
 
209
//---------------------------------------------------------
 
210
 
 
211
const char* MidiXGInstrument::getPatchName(int channel,
 
212
  int hbank, int lbank, int prog, MType)
 
213
      {
 
214
      return getPatch(channel, hbank, lbank, prog, MT_XG);
 
215
      }
 
216
 
 
217
void MidiXGInstrument::populatePatchPopup(QPopupMenu* menu, int, MType songType)
 
218
      {
 
219
      menu->clear();
 
220
      int mask = 0;
 
221
      switch(songType) {
 
222
            case MT_XG: mask = 4; break;
 
223
            case MT_GS:
 
224
            case MT_GM:
 
225
            case MT_UNKNOWN:  mask = 1; break;
 
226
            }
 
227
      for (int i = 0; i < PROG_GROUPS; ++i) {
 
228
            QPopupMenu* pm = new QPopupMenu(menu);
 
229
            pm->setFont(font0);
 
230
            const MidiPatch* mp = patchGroups[i];
 
231
            int k = 0;
 
232
            while (mp->name) {
 
233
                  if (mp->typ & mask) {
 
234
                        int id = (mp->hbank<<16) + (mp->lbank<<8) + mp->prog;
 
235
                        pm->insertItem(mp->name, id);
 
236
                        }
 
237
                  ++k;
 
238
                  ++mp;
 
239
                  }
 
240
            menu->insertItem(gmGroups[i], pm);
 
241
            }
 
242
      }
 
243
 
 
244
ProgItem MidiP50mInstrument::progList[29] = {
 
245
      { "bright piano s+s", 0xffff00 },
 
246
      { "bright piano s",   0xffff01 },
 
247
      { "bright piano m+s", 0xffff02 },
 
248
      { "bright piano m",   0xffff03 },
 
249
      { "dark piano",       0xffff04 },
 
250
      { "grand piano s+s",  0xffff05 },
 
251
      { "grand piano s",    0xffff06 },
 
252
      { "grand piano m+s",  0xffff07 },
 
253
      { "grand piano m",    0xffff08 },
 
254
      { "dance",            0xffff09 },
 
255
      { "honkytonk",        0xffff0a },
 
256
      { "hybrid piano",     0xffff0b },
 
257
      { "cp80, mono",       0xffff0c },
 
258
      { "cp80, mono s",     0xffff0d },
 
259
      { "cp80+chorus",      0xffff0e },
 
260
      { "dx ep",            0xffff0f },
 
261
      { "dx pad",           0xffff10 },
 
262
      { "dx ep+chorus",     0xffff11 },
 
263
      { "roads",            0xffff12 },
 
264
      { "roads+chorus",     0xffff13 },
 
265
      { "soft roads",       0xffff14 },
 
266
      { "hard roads",       0xffff15 },
 
267
      { "dyno",             0xffff16 },
 
268
      { "resonant dyno",    0xffff17 },
 
269
      { "dyno+chorus",      0xffff18 },
 
270
      { "wurli",            0xffff19 },
 
271
      { "clavi",            0xffff1a },
 
272
      { "clavi+wah",        0xffff1b },
 
273
      { "no sound",         0xffff1c },
 
274
      };
 
275
 
 
276
//---------------------------------------------------------
 
277
//   reset
 
278
//---------------------------------------------------------
 
279
 
 
280
void MidiP50mInstrument::reset(int port, MType)
 
281
      {
 
282
      midiPorts[port].gmOn();
 
283
      }
 
284
 
 
285
//---------------------------------------------------------
 
286
//   getPatchName
 
287
//---------------------------------------------------------
 
288
 
 
289
const char* MidiP50mInstrument::getPatchName(int, int, int, int prog, MType)
 
290
      {
 
291
      int nprogs = sizeof(progList)/sizeof(*progList);
 
292
      if (prog > nprogs-1)
 
293
            return "???";
 
294
      return progList[prog].name;
 
295
      }
 
296
 
 
297
void MidiP50mInstrument::populatePatchPopup(QPopupMenu* menu, int, MType)
 
298
      {
 
299
      menu->clear();
 
300
      int nprogs = sizeof(progList)/sizeof(*progList);
 
301
      for (int i = 0; i < nprogs; ++i)
 
302
            menu->insertItem(progList[i].name, progList[i].id);
 
303
      }
 
304
 
 
305
//---------------------------------------------------------
 
306
//   reset
 
307
//    the Korg NS5R is GM/GS/XG compatible
 
308
//---------------------------------------------------------
 
309
 
 
310
void MidiNS5RInstrument::reset(int port, MType _mode)
 
311
      {
 
312
      mode = _mode;
 
313
      switch (mode) {
 
314
            case MT_UNKNOWN:
 
315
            case MT_XG:
 
316
                  midiPorts[port].xgOn();
 
317
                  break;
 
318
            case MT_GS:
 
319
                  midiPorts[port].gsOn();
 
320
                  break;
 
321
            case MT_GM:
 
322
                  midiPorts[port].gmOn();
 
323
                  break;
 
324
            }
 
325
      }
 
326
 
 
327
//---------------------------------------------------------
 
328
//   MidiNS5R::getPatchName
 
329
//---------------------------------------------------------
 
330
 
 
331
const char* MidiNS5RInstrument::getPatchName(int channel,
 
332
  int hbank, int lbank, int prog, MType mode)
 
333
      {
 
334
      return getPatch(channel, hbank, lbank, prog, mode);
 
335
      }
 
336
 
 
337
//---------------------------------------------------------
 
338
//   MidiNS5R::populatePatchPopup
 
339
//---------------------------------------------------------
 
340
 
 
341
void MidiNS5RInstrument::populatePatchPopup(QPopupMenu* menu, int, MType songType)
 
342
      {
 
343
      menu->clear();
 
344
      int mask = 0;
 
345
      switch(songType) {
 
346
            case MT_XG: mask = 4; break;
 
347
            case MT_GS: mask = 2; break;
 
348
            case MT_GM:
 
349
            case MT_UNKNOWN:  mask = 1; break;
 
350
            }
 
351
      for (int i = 0; i < PROG_GROUPS; ++i) {
 
352
            QPopupMenu* pm = new QPopupMenu(menu);
 
353
            pm->setFont(font0);
 
354
            const MidiPatch* mp = patchGroups[i];
 
355
            int k = 0;
 
356
            while (mp->name) {
 
357
                  if (mp->typ & mask) {
 
358
                        int id = (mp->hbank<<16) + (mp->lbank<<8) + mp->prog;
 
359
                        pm->insertItem(mp->name, id);
 
360
                        }
 
361
                  ++k;
 
362
                  ++mp;
 
363
                  }
 
364
            menu->insertItem(gmGroups[i], pm);
 
365
            }
 
366
      }
 
367
 
 
368
//---------------------------------------------------------
 
369
//   readMidiState
 
370
//---------------------------------------------------------
 
371
 
 
372
void MidiInstrument::readMidiState(Xml& xml)
 
373
      {
 
374
      for (;;) {
 
375
            Xml::Token token = xml.parse();
 
376
            const QString& tag = xml.s1();
 
377
            switch (token) {
 
378
                  case Xml::Error:
 
379
                  case Xml::End:
 
380
                        return;
 
381
                  case Xml::TagStart:
 
382
                        if (tag == "event") {
 
383
                              Event* e = new MidiEvent();
 
384
                              e->read(xml);
 
385
                              _midiState->add(e);
 
386
                              }
 
387
                        else
 
388
                              xml.unknown("readMidiState");
 
389
                        break;
 
390
                  case Xml::TagEnd:
 
391
                        if (tag == "midistate")
 
392
                              return;
 
393
                  default:
 
394
                        break;
 
395
                  }
 
396
            }
 
397
      }
 
398
 
 
399
//---------------------------------------------------------
 
400
//   readMidiInit
 
401
//---------------------------------------------------------
 
402
 
 
403
void MidiInstrument::readMidiInit(Xml& xml)
 
404
      {
 
405
      for (;;) {
 
406
            Xml::Token token = xml.parse();
 
407
            const QString& tag = xml.s1();
 
408
            switch (token) {
 
409
                  case Xml::Error:
 
410
                  case Xml::End:
 
411
                        return;
 
412
                  case Xml::TagStart:
 
413
                        if (tag == "event") {
 
414
                              Event* e = new MidiEvent();
 
415
                              e->read(xml);
 
416
                              _midiInit->add(e);
 
417
                              }
 
418
                        else
 
419
                              xml.unknown("readMidiInit");
 
420
                        break;
 
421
                  case Xml::TagEnd:
 
422
                        if (tag == "midiinit")
 
423
                              return;
 
424
                  default:
 
425
                        break;
 
426
                  }
 
427
            }
 
428
      }
 
429