开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
native_midi_gpl.c
资源名称：SDL_mixer-1.2.11.tar.gz　[点击查看]
上传用户：nini_0081
上传日期：2022-07-21
资源大小：2628k
文件大小：11k
源码类别：

多媒体编程

开发平台：

DOS

native_midi_gpl.c：源码内容
  1. /***************************************************************************
  2.                            native_midi_lnx.c
  3.    -----------------
  4.    
  5.     copyright            : (C) 2002 by Peter Ku会k
  6.     email                : kutak@stonline.sk
  7.  ***************************************************************************/
  9. /* in this file is used code from PlayMidi    Copyright (C) 1994-1996 Nathan I. Laredo */
  11. /***************************************************************************
  12.  *                                                                         *
  13.  *   This program is free software; you can redistribute it and/or modify  *
  14.  *   it under the terms of the GNU General Public License as published by  *
  15.  *   the Free Software Foundation; either version 2 of the License, or     *
  16.  *   (at your option) any later version.                                   *
  17.  *                                                                         *
  18.  ***************************************************************************/
  20. #if defined(linux) || defined(__FreeBSD__)
  22. #ifndef __FreeBSD__
  23. #include <getopt.h>
  24. #endif
  25. #include <fcntl.h>
  26. #include <ctype.h>
  27. #include <unistd.h>
  28. #include <sys/stat.h>
  29. #include <string.h>
  30. #include "SDL_thread.h"
  31. #include "native_midi.h"
  32. #include "playmidi.h"
  34. SEQ_DEFINEBUF(SEQUENCERBLOCKSIZE);
  36. int play_fm = 0, play_gus = 0, play_ext = 0, play_awe = 0;
  37. int opl3_patch_aviable = 0, fm_patch_aviable = 0;
  39. struct miditrack seq[MAXTRKS];
  40. struct synth_info card_info[MAX_CARDS];
  42. int FORCE_EXT_DEV = -1;
  43. int chanmask = 0xffff, perc = PERCUSSION;
  44. int dochan = 1, force8bit = 0, wantopl3 = FM_DEFAULT_MODE;
  45. int patchloaded[256], fmloaded[256], useprog[16], usevol[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  46. int reverb = 0, chorus = 0, nrsynths, nrmidis;
  47. int sb_dev = -1, gus_dev = -1, ext_dev = -1, awe_dev = -1, p_remap = 0;
  48. int seqfd,  MT32 = 0;
  49. FILE *mfd;
  50. unsigned long int default_tempo;
  51. float skew = 1.0;
  52. char ImPlaying = 0;
  53. SDL_Thread *playevents_thread=NULL;
  55. extern int ntrks;
  56. extern char *gmvoice[256];
  57. extern int mt32pgm[128];
  58. extern int note_vel[16][128];
  59. extern int playevents();
  60. extern int gus_load(int);
  61. extern int readmidi(unsigned char *, off_t);
  62. extern void loadfm();
  64. void seqbuf_dump();
  65. int synth_setup();
  67. struct _NativeMidiSong
  68. {
  69.     char *filebuf;
  70.     unsigned long int file_size;
  71. };
  73. int native_midi_detect()
  74. {
  76.     int sbfd;
  77.     int ret=0;    
  79.     /* Open sequencer device */
  80.     if ((seqfd = open(SEQUENCER_DEV, O_WRONLY, 0)) < 0) 
  81.     {
  82. perror("open " SEQUENCER_DEV);
  83. return 0;
  84.     }
  86.     gus_dev = -1;
  87.     sb_dev = -1;
  88.     ext_dev = -1;
  89.     awe_dev = -1;
  90.     play_fm = 0;
  91.     play_gus = 0;
  92.     play_ext = 0;
  93.     play_awe = 0;
  94.     
  95.     opl3_patch_aviable = 0;
  96.     fm_patch_aviable = 0;
  98.     sbfd = open(SBMELODIC, O_RDONLY, 0);
  99.     if (sbfd != -1)
  100.     {
  101. close(sbfd);
  102. sbfd = open(SBDRUMS, O_RDONLY, 0);
  103. if (sbfd != -1)
  104. {
  105.             close(sbfd);
  106.     fm_patch_aviable = 1;
  107. }
  108.     }
  110.     sbfd = open(O3MELODIC, O_RDONLY, 0);
  111.     if (sbfd != -1)
  112.     {
  113.         close(sbfd);
  114.         sbfd = open(O3DRUMS, O_RDONLY, 0);
  115. if (sbfd != -1)
  116. {
  117.             close(sbfd);
  118.     opl3_patch_aviable = 1;
  119. }
  120.     }
  122.     ret=synth_setup();
  124.     /* Close sequencer device */
  125.     close(seqfd);
  127.     return ret;
  128. }
  130. NativeMidiSong *native_midi_loadsong(const char *midifile)
  131. {
  132.     NativeMidiSong *song = NULL;
  133.     char  *extra;
  134.     int  piped = 0;
  135.     struct stat  info;
  137.     song = malloc(sizeof(NativeMidiSong));
  138.     if (!song)
  139.     {
  140. return NULL;
  141.     };
  142.     if (stat(midifile, &info) == -1) 
  143.     {
  144.         if ((extra = malloc(strlen(midifile) + 4)) == NULL)
  145.         {
  146.     goto end;
  147. }
  148. sprintf(extra, "%s.mid", midifile);
  149. if (stat(extra, &info) == -1)
  150. {
  151.     free(extra);
  152.     goto end;
  153. }
  154. if ((mfd = fopen(extra, "r")) == NULL)
  155. {
  156.     free(extra);
  157.     goto end;
  158. }
  159. free(extra);
  160.     } else
  161.     {
  162.         char *ext = strrchr(midifile, '.');
  163.         if (ext && strcmp(ext, ".gz") == 0) 
  164. {
  165.     char temp[1024];
  166.     piped = 1;
  167.     sprintf(temp, "gzip -l %s", midifile);
  168.     if ((mfd = popen(temp, "r")) == NULL)
  169.     {
  170.         goto end;
  171.     }
  172.     fgets(temp, sizeof(temp), mfd); /* skip 1st line */
  173.     fgets(temp, sizeof(temp), mfd);
  174.     strtok(temp, " "); /* compressed size */
  175.     info.st_size = atoi(strtok(NULL, " ")); /* original size */
  176.     pclose(mfd);
  177.     sprintf(temp, "gzip -d -c %s",midifile);
  178.     if ((mfd = popen(temp, "r")) == NULL)
  179.     {
  180.         goto end;
  181.     }
  182. }else if ((mfd = fopen(midifile, "r")) == NULL)
  183. {
  184.     goto end;
  185. }
  186.     }
  187.     if ((song->filebuf = malloc(info.st_size)) == NULL)
  188.     {
  189.         if (piped)
  190.         {
  191.     pclose(mfd);
  192. }else
  193. {
  194.     fclose(mfd);
  195. }
  196. goto end;
  197.     }
  198.     song->file_size=info.st_size;
  199.     fread(song->filebuf, 1, info.st_size, mfd);
  200.     if (piped)
  201.     {
  202.         pclose(mfd);
  203.     } else
  204.     {
  205.         fclose(mfd);
  206.     }
  207.     
  208.   return song;
  210. end:
  211.     free(song);
  212.     return NULL;
  213. }
  215. NativeMidiSong *native_midi_loadsong_RW(SDL_RWops *rw)
  216. {
  217. NativeMidiSong *song = NULL;
  218. char  *extra;
  220. song = malloc(sizeof(NativeMidiSong));
  221. if (!song) {
  222. return NULL;
  223. };
  225. SDL_RWseek(rw, 0, RW_SEEK_END);
  226. song->file_size = SDL_RWtell(rw);
  227. SDL_RWseek(rw, 0, RW_SEEK_SET);
  229. song->filebuf = malloc(song->file_size);
  230. if (!song->filebuf) {
  231. free(song);
  232. return NULL;
  233. }
  235. SDL_RWread(rw, song->filebuf, song->file_size, 1);
  236. return song;
  237. }
  239. void native_midi_freesong(NativeMidiSong *song)
  240. {
  241.     free(song->filebuf);
  242.     free(song);
  243. }
  245. void native_midi_start(NativeMidiSong *song)
  246. {
  248.     int i, error = 0, j;
  250.     for (i = 0; i < 16; i++)
  251.     {
  252. useprog[i] = 0; /* reset options */
  253.     }
  254.     
  255.     /* Open sequencer device */
  256.     if ((seqfd = open(SEQUENCER_DEV, O_WRONLY, 0)) < 0) 
  257.     {
  258. perror("open " SEQUENCER_DEV);
  259. goto eend;
  260.     }
  261.     if(!synth_setup()) { goto end;};
  264.     if (play_gus)
  265.     {
  266. gus_load(-1);
  267.     }
  268.     default_tempo = 500000;
  269.     /* error holds number of tracks read */
  270.     error = readmidi(song->filebuf, song->file_size);
  271.     if (play_gus && error > 0) 
  272.     {
  273. int i; /* need to keep other i safe */
  274. #define CMD (seq[i].data[j] & 0xf0)
  275. #define CHN (seq[i].data[j] & 0x0f)
  276. #define PGM (seq[i].data[j + 1])
  277. /* REALLY STUPID way to preload GUS, but it works */
  278. for (i = 0; i < ntrks; i++)
  279.     for (j = 0; j < seq[i].length - 5; j++)
  280. if (ISGUS(CHN) && !(PGM & 0x80) &&
  281.     ((CMD == MIDI_PGM_CHANGE && !ISPERC(CHN))
  282.      || (CMD == MIDI_NOTEON && ISPERC(CHN))))
  283.     gus_load(ISPERC(CHN) ? PGM + 128 :
  284.      useprog[CHN] ? useprog[CHN] - 1 :
  285.      MT32 ? mt32pgm[PGM] : PGM);
  286. /* make sure that some program was loaded to use */
  287. for (j = 0; patchloaded[j] != 1 && j < 128; j++);
  288. if (j > 127)
  289.     gus_load(0);
  290.     }
  291. /* if there's an error skip to next file */
  292.     if (error > 0) /* error holds number of tracks read */
  293.     {
  294. ImPlaying=1;
  295.      playevents_thread=SDL_CreateThread(playevents,NULL);
  296.     }
  298. end:
  299. eend:
  300.     return;
  301. }
  303. void native_midi_stop()
  304. {
  305.     /* Close sequencer device */
  306.     close(seqfd);
  307. }
  309. int native_midi_active()
  310. {
  311.     return ImPlaying;
  312. }
  314. void native_midi_setvolume(int volume)
  315. {
  316. }
  318. const char *native_midi_error(void)
  319. {
  320.   return "stala sa chyba";
  321. }
  323. void seqbuf_dump()
  324. {
  325.     if (_seqbufptr)
  326. if (write(seqfd, _seqbuf, _seqbufptr) == -1) {
  327.     perror("write " SEQUENCER_DEV);
  328.     return;
  329. }
  330.     _seqbufptr = 0;
  331. }
  333. int synth_setup()
  334. {
  335.     int i;
  336.     char *nativemusicenv = getenv("SDL_NATIVE_MUSIC");
  337.     char *extmidi=getenv("SDL_NATIVE_MUSIC_EXT");
  339.     if(extmidi)
  340.     {
  342.      FORCE_EXT_DEV = atoi(extmidi);
  343. printf("EXT midi %s , %d n",extmidi,FORCE_EXT_DEV);
  344.     }
  345.     
  346.     if (ioctl(seqfd, SNDCTL_SEQ_NRSYNTHS, &nrsynths) == -1) 
  347.     {
  348. fprintf(stderr, "there is no soundcardn");
  349. return 0;
  350.     }
  351.     for (i = 0; i < nrsynths; i++) 
  352.     {
  353. card_info[i].device = i;
  354. if (ioctl(seqfd, SNDCTL_SYNTH_INFO, &card_info[i]) == -1) 
  355. {
  356.     fprintf(stderr, "cannot get info on soundcardn");
  357.     perror(SEQUENCER_DEV);
  358.     return 0;
  359. }
  360. card_info[i].device = i;
  361. if (card_info[i].synth_type == SYNTH_TYPE_SAMPLE
  362.     && card_info[i].synth_subtype == SAMPLE_TYPE_GUS)
  363. {
  364.     gus_dev = i;
  365. }else if (card_info[i].synth_type == SYNTH_TYPE_SAMPLE
  366.     && card_info[i].synth_subtype == SAMPLE_TYPE_AWE32)
  367. {
  368.     awe_dev = i;
  369. }else if (card_info[i].synth_type == SYNTH_TYPE_FM) 
  370. {
  371.     sb_dev = i;
  372.     if (play_fm)
  373. loadfm();
  374.     if (wantopl3) 
  375.     {
  376. card_info[i].nr_voices = 12; /* we have 12 with 4-op */
  377.     }
  378. }
  379.     }
  381.     if (gus_dev >= 0) {
  382. if (ioctl(seqfd, SNDCTL_SEQ_RESETSAMPLES, &gus_dev) == -1) 
  383. {
  384.     perror("Sample reset");
  385.     return 0;
  386. }
  387.     }
  388.     if (ioctl(seqfd, SNDCTL_SEQ_NRMIDIS, &nrmidis) == -1) 
  389.     {
  390. fprintf(stderr, "can't get info about midi portsn");
  391. return 0;
  392.     }
  393.     if (nrmidis > 0) {
  394. if (FORCE_EXT_DEV >= 0)
  395.     ext_dev = FORCE_EXT_DEV;
  396. else
  397.     ext_dev = nrmidis - 1;
  398.     }
  400.     if( nativemusicenv ) /* select device by SDL_NATIVE_MUSIC */
  401.     {
  402. if(strcasecmp(nativemusicenv,"GUS") == 0)
  403. {
  404.          if( gus_dev >= 0 )
  405.     {
  406.      play_gus = -1;
  407.         awe_dev = -1;
  408. sb_dev  = -1;
  409.         ext_dev = -1;
  410.         return 1;
  411.             }else
  412.     {
  413.      play_gus = 0;
  414. return 0;
  415.     }
  416. }else if(strcasecmp(nativemusicenv,"AWE") == 0)
  417. {
  418.          if( awe_dev >= 0 )
  419.     {
  420.      play_awe = -1;
  421.         gus_dev = -1;
  422. sb_dev  = -1;
  423.         ext_dev = -1;
  424.         return 1;
  425.             }else
  426.     {
  427.      play_awe = 0;
  428. return 0;
  429.     }
  430. }else if(strcasecmp(nativemusicenv,"FM") == 0)
  431. {
  432.          if( sb_dev >= 0 && fm_patch_aviable )
  433.     {
  434.      play_fm = -1;
  435. gus_dev = -1;
  436.         awe_dev = -1;
  437.         ext_dev = -1;
  438.         wantopl3 = 0;
  439.         return 1;
  440.             }else
  441.     {
  442.      play_fm = 0;
  443. return 0;
  444.     }
  445. }else if(strcasecmp(nativemusicenv,"OPL3") == 0)
  446. {
  447.          if( sb_dev >= 0 && opl3_patch_aviable )
  448.     {
  449.      play_fm = -1;
  450. gus_dev = -1;
  451.         awe_dev = -1;
  452.         ext_dev = -1;
  453.         wantopl3 = 1;
  454.         return 1;
  455.             }else
  456.     {
  457.      play_fm = 0;
  458. return 0;
  459.     }
  460. }else if(strcasecmp(nativemusicenv,"EXT") == 0)
  461. {
  462.          if( ext_dev >= 0 )
  463.     {
  464.      play_ext = -1;
  465.         gus_dev = -1;
  466.         awe_dev = -1;
  467. sb_dev  = -1;
  468.         return 1;
  469.             }else
  470.     {
  471.      play_ext = 0;
  472. return 0;
  473.     }
  474. }
  475.     }
  476.     /* autoselect best device */
  477.     if( gus_dev >= 0 )
  478.     {
  479.         play_gus = -1;
  480.         awe_dev = -1;
  481.         sb_dev  = -1;
  482.         ext_dev = -1;
  483.         return 1;
  484.         }
  485.     if( awe_dev >= 0 )
  486.     {
  487.         play_awe = -1;
  488. gus_dev = -1;
  489.         sb_dev  = -1;
  490.         ext_dev = -1;
  491.         return 1;
  492.     }
  493.     if( sb_dev >= 0 && fm_patch_aviable )
  494.     {
  495.         play_fm = -1;
  496. gus_dev = -1;
  497.         awe_dev = -1;
  498.         ext_dev = -1;
  499.         return 2; /* return 1 if use FM befor Timidity */
  500.     }
  501.     if( ext_dev >= 0 )
  502.     {
  503.         play_ext = -1;
  504. gus_dev = -1;
  505.         awe_dev = -1;
  506.         sb_dev  = -1;
  507.         return 3;
  508.     }
  509.     return 0;
  510. }
  512. #endif /* linux || FreeBSD */