• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • libtdemid
 

libtdemid

  • libtdemid
gusout.cpp
1 /**************************************************************************
2 
3  gusout.cpp - class GUSOut which implements support for Gravis
4  Ultrasound cards through a /dev/sequencer device
5  This file is part of LibKMid 0.9.5
6  Copyright (C) 1998,99,2000 Antonio Larrosa Jimenez
7  LibKMid's homepage : http://www.arrakis.es/~rlarrosa/libtdemid.html
8 
9  This library is free software; you can redistribute it and/or
10  modify it under the terms of the GNU Library General Public
11  License as published by the Free Software Foundation; either
12  version 2 of the License, or (at your option) any later version.
13 
14  This library is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  Library General Public License for more details.
18 
19  You should have received a copy of the GNU Library General Public License
20  along with this library; see the file COPYING.LIB. If not, write to
21  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  Boston, MA 02110-1301, USA.
23 
24  Send comments and bug fixes to Antonio Larrosa <larrosa@kde.org>
25 
26 ***************************************************************************/
27 #include "gusout.h"
28 #include "sndcard.h"
29 #include "midispec.h"
30 #include "gusvoices.h"
31 #include <sys/stat.h>
32 #include <unistd.h>
33 #include <fcntl.h>
34 #include <stdio.h>
35 #include <sys/ioctl.h>
36 #include <errno.h>
37 #include <string.h>
38 #include <sys/param.h>
39 #include <stdlib.h>
40 #ifdef HAVE_CONFIG_H
41 #include <config.h>
42 #endif
43 
44 SEQ_USE_EXTBUF();
45 
46 #ifdef HAVE_OSS_SUPPORT
47 struct pat_header
48 {
49  char magic[12];
50  char version[10];
51  char description[60];
52  unsigned char instruments;
53  char voices;
54  char channels;
55  unsigned short nr_waveforms;
56  unsigned short master_volume;
57  unsigned long data_size;
58 };
59 struct sample_header
60 {
61  char name[7];
62  unsigned char fractions;
63  long len;
64  long loop_start;
65  long loop_end;
66  unsigned short base_freq;
67  long low_note;
68  long high_note;
69  long base_note;
70  short detune;
71  unsigned char panning;
72 
73  unsigned char envelope_rate[6];
74  unsigned char envelope_offset[6];
75 
76  unsigned char tremolo_sweep;
77  unsigned char tremolo_rate;
78  unsigned char tremolo_depth;
79 
80  unsigned char vibrato_sweep;
81  unsigned char vibrato_rate;
82  unsigned char vibrato_depth;
83 
84  char modes;
85 
86  short scale_frequency;
87  unsigned short scale_factor;
88 };
89 
90 int get_dint(unsigned char *p)
91 {
92  unsigned int v=0;
93 
94  for (int i=0;i<4;i++)
95  {
96  v |= (p[i] << (i*8));
97  }
98  return (int)v;
99 }
100 
101 unsigned short get_word(unsigned char *p)
102 {
103  unsigned short v=0;
104 
105  for (int i=0;i<2;i++)
106  v |= (*p++ << (i*8));
107  return (short)v;
108 }
109 
110 #endif
111 
112 GUSOut::GUSOut(int d,int total)
113 {
114  seqfd = -1;
115  devicetype=KMID_GUS;
116  device= d;
117  _ok=1;
118 
119  use8bit=0;
120  nvoices=total;
121  vm=new VoiceManager(nvoices);
122 }
123 
124 GUSOut::~GUSOut()
125 {
126  closeDev();
127 
128  delete vm;
129  if (delete_GUS_patches_directory)
130  {
131  free((char *)GUS_patches_directory);
132  delete_GUS_patches_directory = 0;
133  GUS_patches_directory="/etc";
134  }
135 }
136 
137 void GUSOut::openDev (int sqfd)
138 {
139  _ok=1;
140  seqfd = sqfd;
141  //vm->clearLists();
142  if (seqfd==-1)
143  {
144  printfdebug("ERROR: Could not open /dev/sequencer\n");
145  return;
146  }
147 
148 #ifdef HAVE_OSS_SUPPORT
149 
150  //seqbuf_clean();
151  //ioctl(seqfd,SNDCTL_SEQ_RESET);
152  //ioctl(seqfd,SNDCTL_SEQ_PANIC);
153 
154  if (ioctl(seqfd, SNDCTL_SEQ_RESETSAMPLES, &device)==-1)
155  {
156  printfdebug("Error reseting gus samples. Please report\n");
157  };
158  use8bit=0;
159  totalmemory = device;
160  ioctl(seqfd, SNDCTL_SYNTH_MEMAVL, &totalmemory);
161  freememory = device;
162  ioctl(seqfd, SNDCTL_SYNTH_MEMAVL, &freememory);
163 
164 #endif
165 
166 
167 }
168 
169 void GUSOut::closeDev (void)
170 {
171  if (!ok()) return;
172  vm->clearLists();
173  //if (seqfd>=0)
174  // close(seqfd);
175  seqfd=-1;
176 }
177 
178 void GUSOut::initDev (void)
179 {
180 #ifdef HAVE_OSS_SUPPORT
181  int chn;
182  if (!ok()) return;
183  uchar gm_reset[5]={0x7e, 0x7f, 0x09, 0x01, 0xf7};
184  sysex(gm_reset, sizeof(gm_reset));
185  for (chn=0;chn<16;chn++)
186  {
187  chnmute[chn]=0;
188  chnPatchChange(chn,0);
189  // chnPressure(chn,127);
190  chnPitchBender(chn, 0x00, 0x40);
191  chnController(chn, CTL_MAIN_VOLUME,127);
192  chnController(chn, CTL_EXT_EFF_DEPTH, 0);
193  chnController(chn, CTL_CHORUS_DEPTH, 0);
194  chnController(chn, 0x4a, 127);
195  }
196 
197 
198  for (int i = 0; i < nvoices; i++)
199  {
200  SEQ_CONTROL(device, i, SEQ_VOLMODE, VOL_METHOD_LINEAR);
201  SEQ_STOP_NOTE(device, i, vm->note(i), 64);
202  }
203 
204 #endif
205 }
206 
207 
208 int GUSOut::patch(int p)
209 {
210  if (patchloaded[p]==1) return p;
211  printfdebug("Not loaded %d!\n",p);
212  p=0;
213  while ((p<256)&&(patchloaded[p]==0)) p++;
214  return p;
215 }
216 
217 void GUSOut::noteOn (uchar chn, uchar note, uchar vel)
218 {
219  if (vel==0)
220  {
221  noteOff(chn,note,vel);
222  }
223  else
224  {
225  if (chn==PERCUSSION_CHANNEL)
226  {
227  if (patchloaded[note+128]==0) return;
228  else
229  if (patchloaded[chnpatch[chn]]==0) return;
230  };
231  int v=vm->allocateVoice(chn,note);
232  int p;
233  if (chn==PERCUSSION_CHANNEL)
234  SEQ_SET_PATCH(device,v ,p=patch(note+128))
235  else
236  SEQ_SET_PATCH(device,v ,p=map->patch(chn,chnpatch[chn]));
237  SEQ_BENDER(device, v, chnbender[chn]);
238 
239  SEQ_START_NOTE(device, v, note, vel);
240  // SEQ_CONTROL(device, v, CTL_MAIN_VOLUME, chncontroller[chn][CTL_MAIN_VOLUME]);
241  SEQ_CHN_PRESSURE(device, v , chnpressure[chn]);
242  }
243 
244  printfdebug("Note ON >\t chn : %d\tnote : %d\tvel: %d\n",chn,note,vel);
245 }
246 
247 void GUSOut::noteOff (uchar chn, uchar note, uchar vel)
248 {
249  int i;
250  vm->initSearch();
251  while ((i=vm->search(chn,note))!=-1)
252  {
253  SEQ_STOP_NOTE(device, i, note, vel);
254  vm->deallocateVoice(i);
255  }
256 
257 #ifdef GUSOUTDEBUG
258  printf("Note OFF >\t chn : %d\tnote : %d\tvel: %d\n",chn,note,vel);
259 #endif
260 }
261 
262 void GUSOut::keyPressure (uchar chn, uchar note, uchar vel)
263 {
264  int i;
265  vm->initSearch();
266  while ((i=vm->search(chn,note))!=-1)
267  SEQ_KEY_PRESSURE(device, i, note,vel);
268 }
269 
270 void GUSOut::chnPatchChange (uchar chn, uchar patch)
271 {
272  if (chn==PERCUSSION_CHANNEL) return;
273  int i;
274  vm->initSearch();
275  while ((i=vm->search(chn))!=-1)
276  SEQ_SET_PATCH(device,i,map->patch(chn,patch));
277  chnpatch[chn]=patch;
278 
279 }
280 
281 void GUSOut::chnPressure (uchar /*chn*/, uchar /*vel*/)
282 {
283  /* int i;
284  vm->initSearch();
285  while ((i=vm->search(chn))!=-1)
286  SEQ_CHN_PRESSURE(device, i , vel);
287  chnpressure[chn]=vel;
288  */
289 }
290 
291 void GUSOut::chnPitchBender(uchar chn,uchar lsb, uchar msb)
292 {
293  chnbender[chn]=((int)msb<<7) | (lsb & 0x7F);
294 
295  int i;
296  vm->initSearch();
297  while ((i=vm->search(chn))!=-1)
298  SEQ_BENDER(device, i, chnbender[chn]);
299 }
300 
301 void GUSOut::chnController (uchar chn, uchar ctl, uchar v)
302 {
303  if ((ctl==11)||(ctl==7))
304  {
305  v=(v*volumepercentage)/100;
306  if (v>127) v=127;
307  };
308 
309  int i;
310  vm->initSearch();
311  while ((i=vm->search(chn))!=-1)
312  SEQ_CONTROL(device, i, ctl, v);
313 
314  chncontroller[chn][ctl]=v;
315 }
316 
317 void GUSOut::sysex(uchar *, ulong )
318 {
319 
320 }
321 
322 void GUSOut::setGUSPatchesDirectory(const char *dir)
323 {
324  if ((dir==NULL)||(dir[0]==0)) return;
325  if (delete_GUS_patches_directory)
326  free((char *)GUS_patches_directory);
327 
328  GUS_patches_directory = strdup(dir);
329  delete_GUS_patches_directory=1;
330 }
331 
332 const char *GUSOut::patchName(int pgm)
333 {
334  return GUS_voice_names[pgm];
335 }
336 
337 
338 int GUSOut::loadPatch(int pgm)
339 {
340 #ifdef HAVE_OSS_SUPPORT
341  struct pat_header header;
342  struct sample_header sample;
343  if (patchloaded[pgm]==1)
344  {
345 #ifdef GUSOUTDEBUG
346  printf("Trying to reload a patch. This should never happen, please report.\n");
347 #endif
348  return 0;
349  }
350  if ((patchName(pgm)==NULL)||((patchName(pgm))[0]==0))
351  {
352 #ifdef GUSOUTDEBUG
353  printf("Couldn't guess patch name for patch number %d\n",pgm);
354 #endif
355  return -1;
356  }
357  char *s=new char[strlen(GUS_patches_directory)+strlen(patchName(pgm))+10];
358  if (s==NULL) return -1;
359  sprintf(s,"%s/%s.pat",GUS_patches_directory,patchName(pgm));
360 #ifdef GUSOUTDEBUG
361  printf("Loading patch : %s\n",s);
362 #endif
363  struct patch_info *patch=NULL;
364  struct stat info;
365  if (stat(s, &info)==-1)
366  {
367 #ifdef GUSOUTDEBUG
368  printf("File %s doesn't exist\n",s);
369 #endif
370  return -1;
371  }
372 
373  FILE *fh=fopen(s,"rb");
374  if (fh==NULL)
375  {
376 #ifdef GUSOUTDEBUG
377  printf("Couldn't open patch %s\n",s);
378 #endif
379  return -1;
380  }
381 
382  unsigned char tmp[256];
383  if (fread(tmp,1,0xef,fh)!=0xef)
384  {
385  fclose(fh);
386 #ifdef GUSOUTDEBUG
387  printf("Short file ! \n");
388 #endif
389  return -1;
390  }
391  memcpy ((char *) &header, tmp, sizeof (header));
392 
393  if (strncmp(header.magic,"GF1PATCH110",12)!=0)
394  {
395 #ifdef GUSOUTDEBUG
396  printf("File %s is corrupted or it isn't a patch file\n",s);
397 #endif
398  return -1;
399  }
400  if (strncmp(header.version,"ID#000002",10)!=0)
401  {
402 #ifdef GUSOUTDEBUG
403  printf("File %s's version is not supported\n",s);
404 #endif
405  return -1;
406  }
407  unsigned short nWaves= *(unsigned short *)&tmp[85];
408 #ifdef GUSOUTDEBUG
409  unsigned short masterVolume= *(unsigned short *)&tmp[87];
410  printf("nWaves: %d\n",nWaves);
411  printf("masterVolume : %d\n",masterVolume);
412 #endif
413 
414  unsigned short i;
415  int offset=0xef;
416  for (i=0;i<nWaves;i++)
417  {
418  fseek(fh,offset,SEEK_SET);
419 
420  if (fread(tmp,1,sizeof(sample),fh) != sizeof(sample))
421  {
422  fclose(fh);
423 #ifdef GUSOUTDEBUG
424  printf("Short file\n");
425 #endif
426  return -1;
427  }
428  memcpy ((char *) &sample, tmp, sizeof (sample));
429  sample.fractions = (char)tmp[7];
430  sample.len = get_dint(&tmp[8]);
431  sample.loop_start = get_dint(&tmp[12]);
432  sample.loop_end = get_dint(&tmp[16]);
433  sample.base_freq = get_word(&tmp[20]);
434  sample.low_note = get_dint(&tmp[22]);
435  sample.high_note = get_dint(&tmp[26]);
436  sample.base_note = get_dint(&tmp[30]);
437  sample.detune = (short)get_word(&tmp[34]);
438  sample.panning = (unsigned char) tmp[36];
439 
440  memcpy (sample.envelope_rate, &tmp[37], 6);
441  memcpy (sample.envelope_offset, &tmp[43], 6);
442 
443  sample.tremolo_sweep = (unsigned char) tmp[49];
444  sample.tremolo_rate = (unsigned char) tmp[50];
445  sample.tremolo_depth = (unsigned char) tmp[51];
446 
447  sample.vibrato_sweep = (unsigned char) tmp[52];
448  sample.vibrato_rate = (unsigned char) tmp[53];
449  sample.vibrato_depth = (unsigned char) tmp[54];
450  sample.modes = (unsigned char) tmp[55];
451  sample.scale_frequency = (short)get_word(&tmp[56]);
452  sample.scale_factor = get_word(&tmp[58]);
453 
454  offset = offset + 96;
455 
456  patch = (struct patch_info *) malloc(sizeof (*patch) + sample.len);
457  if (patch == NULL)
458  {
459 #ifdef GUSOUTDEBUG
460  printf("Not enough memory\n");
461 #endif
462  return -1;
463  }
464  patch->key = GUS_PATCH;
465  patch->device_no = device;
466  patch->instr_no = pgm;
467  patch->mode = sample.modes | WAVE_TREMOLO | WAVE_VIBRATO | WAVE_SCALE;
468  patch->len = sample.len;
469  patch->loop_start = sample.loop_start;
470  patch->loop_end = sample.loop_end;
471  patch->base_note = sample.base_note;
472  patch->high_note = sample.high_note;
473  patch->low_note = sample.low_note;
474  patch->base_freq = sample.base_freq;
475  patch->detuning = sample.detune;
476  patch->panning = (sample.panning - 7) * 16;
477 
478  memcpy (patch->env_rate, sample.envelope_rate, 6);
479  memcpy (patch->env_offset, sample.envelope_offset, 6);
480 
481  patch->tremolo_sweep = sample.tremolo_sweep;
482  patch->tremolo_rate = sample.tremolo_rate;
483  patch->tremolo_depth = sample.tremolo_depth;
484 
485  patch->vibrato_sweep = sample.vibrato_sweep;
486  patch->vibrato_rate = sample.vibrato_rate;
487  patch->vibrato_depth = sample.vibrato_depth;
488 
489  patch->scale_frequency = sample.scale_frequency;
490  patch->scale_factor = sample.scale_factor;
491 
492  patch->volume = header.master_volume;
493 
494  if (fseek (fh, offset, 0) == -1)
495  {
496  fclose(fh);
497  return -1;
498  }
499 
500  if ((long)fread (patch->data, 1,sample.len,fh) != sample.len)
501  {
502 #ifdef GUSOUTDEBUG
503  printf ("Short file\n");
504 #endif
505  return -1;
506  }
507 
508  SEQ_WRPATCH (patch, sizeof (*patch) + sample.len);
509 
510  offset = offset + sample.len;
511 
512  }
513  patchloaded[pgm]=1;
514 
515  fclose(fh);
516  free(patch); // Shouldn't this 'free' be within the 'for' loop ?
517  delete s;
518  freememory = device;
519  ioctl(seqfd, SNDCTL_SYNTH_MEMAVL, &freememory);
520 #endif
521  return 0;
522 }
523 
524 
525 void GUSOut::setPatchesToUse(int *patchesused)
526 {
527 #ifdef HAVE_OSS_SUPPORT
528  int k;
529  for (k=0;k<256;k++) patchloaded[k]=0;
530 
531  int patchesordered[256]; //This holds the pgm used ordered by a method which
532  // put first the patches more oftenly used, and then the least
533  // In example, if a song only uses a piano and a splash cymbal,
534  // This is set to : 0,188,-1,-1,-1,-1 ...
535  patchesLoadingOrder(patchesused,patchesordered);
536 
537  // If above line doesn't work, perhaps you could try this ? :
538  // for (int j=0;j<256;j++) patchesordered[j]=patchesused[j];
539 #ifdef GUSOUTDEBUG
540  printf("Patches used : \n");
541  for (k=0;k<256;k++)
542  {
543  if (patchesused[k]!=-1) printf("%d,",patchesused[k]);
544  }
545  printf("\n Patches used, sorted :\n");
546  for (k=0;k<256;k++)
547  {
548  if (patchesordered[k]!=-1) printf("%d,",patchesordered[k]);
549  }
550 #endif
551 
552  int i=0;
553  while (patchesordered[i]!=-1)
554  {
555 #ifdef GUSOUTDEBUG
556  printf("Load Patch : %d\n",patchesordered[i]);
557 #endif
558  loadPatch(patchesordered[i]);
559  i++;
560  }
561 #endif
562 }
563 
564 int compare_decreasing(const void *a,const void *b)
565 {
566  struct instr_gm
567  {
568  int used;
569  int pgm;
570  };
571  instr_gm *ai=(instr_gm *)a;
572  instr_gm *bi=(instr_gm *)b;
573  return ai->used<bi->used;
574 }
575 
576 
577 void GUSOut::patchesLoadingOrder(int *patchesused,int *patchesordered)
578 {
579  struct instr_gm
580  {
581  int used;
582  int pgm;
583  };
584 
585  instr_gm tempmelody[128];
586  instr_gm tempdrums[128];
587  int i,j;
588  for (i=0,j=128;i<128;i++,j++)
589  {
590  tempmelody[i].used=patchesused[i];
591  tempmelody[i].pgm=i;
592  tempdrums[i].used=patchesused[j];
593  tempdrums[i].pgm=j;
594  }
595  /* SORT */ // Decreasing order (first most used patch, then less used patch)
596  qsort(&tempmelody[0],128,sizeof(instr_gm),compare_decreasing);
597  qsort(&tempdrums[0],128,sizeof(instr_gm),compare_decreasing);
598 
599  /* Once they are sorted, the result is put on patchesordered in the following
600  * way : If tempmelody is : M0 M1 M2 M3 ... M127 and tempdrums is :
601  * D0 D1 D2 D3 ... D127, the result is :
602  * M0 D0 M1 M2 D1 M3 M4 D2 M5 M6 D3 ...
603  * P0 P1 P2 P3 P4 P5 P6 P7 P8 P9 P10 ...
604  */
605 
606 #ifdef GUSOUTDEBUG
607  for (int k=0;k<128;k++)
608  {
609  printf("%d - %d\n",tempmelody[k].used,tempmelody[k].pgm);
610  }
611  for (int k=0;k<128;k++)
612  {
613  printf("%d : %d\n",tempdrums[k].used,tempdrums[k].pgm);
614  }
615 #endif
616 
617  i=0;
618  int totalmelody=0;
619  while ((i<128)&&(tempmelody[i].used!=0))
620  {
621  totalmelody++;
622  i++;
623  }
624  i=0;
625  int totaldrums=0;
626  while ((i<128)&&(tempdrums[i].used!=0))
627  {
628  totaldrums++;
629  i++;
630  }
631 #ifdef GUSOUTDEBUG
632  printf("Totalmelody : %d,totaldrums : %d\n",totalmelody,totaldrums);
633 #endif
634  int tgt=0;
635 
636  int tm=totalmelody;
637  int td=totaldrums;
638  int cm,cd;
639  cm=cd=0;
640  if ((tm!=0)&&(td!=0))
641  {
642  patchesordered[0]=tempmelody[0].pgm;
643  patchesordered[1]=tempdrums[0].pgm;
644  tm--;td--;
645  cm++;cd++;
646  tgt+=2;
647  while ((tm>0)&&(td>0))
648  {
649  if (((tgt-1)%3)==0)
650  {
651  patchesordered[tgt]=tempdrums[cd].pgm;
652  cd++;
653  td--;
654  }
655  else
656  {
657  patchesordered[tgt]=tempmelody[cm].pgm;
658  cm++;
659  tm--;
660  }
661  tgt++;
662  }
663  }
664  while (tm>0)
665  {
666  patchesordered[tgt]=tempmelody[cm].pgm;
667  tgt++;
668  cm++;
669  tm--;
670  }
671  while (td>0)
672  {
673  patchesordered[tgt]=tempdrums[cd].pgm;
674  tgt++;
675  cd++;
676  td--;
677  }
678 
679  // Now we put as not used (-1) the rest of the array
680  while (tgt<256)
681  {
682  patchesordered[tgt]=-1;
683  tgt++;
684  }
685 }
686 
687 //char *GUSOut::GUS_patches_directory="/mnt/dosc/gravis/patches";
688 const char *GUSOut::GUS_patches_directory="/usr/share/ultrasnd";
689 
690 int GUSOut::delete_GUS_patches_directory = 0;
691 /* No, this doesn't delete any file :-) it's just for internal use */
TDEStdAccel::description
TQString description(StdAccel id) KDE_DEPRECATED
GUSOut::setPatchesToUse
void setPatchesToUse(int *patchesused)
See DeviceManager::setPatchesToUse() .
Definition: gusout.cpp:525
GUSOut::openDev
virtual void openDev(int sqfd)
See MidiOut::openDev()
Definition: gusout.cpp:137
GUSOut::patch
int patch(int p)
Returns p if the patch with number p has been correctly loaded.
Definition: gusout.cpp:208
GUSOut::noteOn
virtual void noteOn(uchar chn, uchar note, uchar vel)
See MidiOut::noteOn()
Definition: gusout.cpp:217
GUSOut::chnPressure
virtual void chnPressure(uchar chn, uchar vel)
See MidiOut::chnPressure()
Definition: gusout.cpp:281
GUSOut::loadPatch
int loadPatch(int pgm)
Loads a single patch on the synthesizer memory.
Definition: gusout.cpp:338
GUSOut::~GUSOut
~GUSOut()
Destructor.
Definition: gusout.cpp:124
GUSOut::chnPatchChange
virtual void chnPatchChange(uchar chn, uchar patch)
See MidiOut::chnPatchChange()
Definition: gusout.cpp:270
GUSOut::GUSOut
GUSOut(int d=0, int total=12)
Constructor.
Definition: gusout.cpp:112
GUSOut::closeDev
virtual void closeDev(void)
See MidiOut::closeDev()
Definition: gusout.cpp:169
GUSOut::initDev
virtual void initDev(void)
See MidiOut::initDev()
Definition: gusout.cpp:178
GUSOut::sysex
virtual void sysex(uchar *data, ulong size)
It's an empty function, as GUS synths don't support System Exclusive messages.
Definition: gusout.cpp:317
MidiMapper::patch
uchar patch(uchar chn, uchar pgm)
Returns the patch which pgm used on channel chn should be mapped to.
Definition: midimapper.cpp:431
GUSOut::chnController
virtual void chnController(uchar chn, uchar ctl, uchar v)
See MidiOut::chnController()
Definition: gusout.cpp:301
GUSOut::chnPitchBender
virtual void chnPitchBender(uchar chn, uchar lsb, uchar msb)
See MidiOut::chnPitchBender()
Definition: gusout.cpp:291
MidiOut::ok
int ok(void)
Returns true if everything's ok and false if there has been any problem.
Definition: midiout.h:231
GUSOut::setGUSPatchesDirectory
static void setGUSPatchesDirectory(const char *dir)
Sets the directory where the GUS patches are stored, that is, where the acpiano.pat, ...
Definition: gusout.cpp:322
KDE::version
unsigned int version()
GUSOut::keyPressure
virtual void keyPressure(uchar chn, uchar note, uchar vel)
See MidiOut::keyPressure()
Definition: gusout.cpp:262
GUSOut::noteOff
virtual void noteOff(uchar chn, uchar note, uchar vel)
See MidiOut::noteOff()
Definition: gusout.cpp:247
TDEStdAccel::name
TQString name(StdAccel id)

libtdemid

Skip menu "libtdemid"
  • Main Page
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Class Members
  • Related Pages

libtdemid

Skip menu "libtdemid"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  •     tdecore
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  • tdeioslave
  •   http
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for libtdemid by doxygen 1.8.8
This website is maintained by Timothy Pearson.