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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
mdriver.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：21k
源码类别：

Windows CE

开发平台：

C/C++

mdriver.c：源码内容
  1. /* MikMod sound library
  2. (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
  3. for complete list.
  5. This library is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU Library General Public License as
  7. published by the Free Software Foundation; either version 2 of
  8. the License, or (at your option) any later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU Library General Public License for more details.
  14.  
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18. 02111-1307, USA.
  19. */
  21. /*==============================================================================
  23.   $Id: mdriver.c,v 1.3 2004/02/18 13:29:19 raph Exp $
  25.   These routines are used to access the available soundcard drivers.
  27. ==============================================================================*/
  29. #ifdef HAVE_CONFIG_H
  30. #include "config.h"
  31. #endif
  33. #ifdef HAVE_UNISTD_H
  34. #include <unistd.h>
  35. #endif
  37. #if defined unix || (defined __APPLE__ && defined __MACH__)
  38. #include <pwd.h>
  39. #include <sys/stat.h>
  40. #endif
  42. #include <string.h>
  43. #ifdef HAVE_STRINGS_H
  44. #include <strings.h>
  45. #endif
  47. #include "mikmod_internals.h"
  49. #ifdef SUNOS
  50. extern int fprintf(FILE *, const char *, ...);
  51. #endif
  53. static MDRIVER *firstdriver=NULL;
  54. MIKMODAPI MDRIVER *md_driver=NULL;
  55. extern MODULE *pf; /* modfile being played */
  57. /* Initial global settings */
  58. MIKMODAPI UWORD md_device         = 0; /* autodetect */
  59. MIKMODAPI UWORD md_mixfreq        = 44100;
  60. MIKMODAPI UWORD md_mode           = DMODE_STEREO | DMODE_16BITS |
  61.   DMODE_SURROUND |DMODE_SOFT_MUSIC |
  62.   DMODE_SOFT_SNDFX;
  63. MIKMODAPI UBYTE md_pansep         = 128; /* 128 == 100% (full left/right) */
  64. MIKMODAPI UBYTE md_reverb         = 0; /* no reverb */
  65. MIKMODAPI UBYTE md_volume         = 128; /* global sound volume (0-128) */
  66. MIKMODAPI UBYTE md_musicvolume    = 128; /* volume of song */
  67. MIKMODAPI UBYTE md_sndfxvolume    = 128; /* volume of sound effects */
  68. UWORD md_bpm            = 125; /* tempo */
  70. /* Do not modify the numchn variables yourself!  use MD_SetVoices() */
  71. UBYTE md_numchn=0,md_sngchn=0,md_sfxchn=0;
  72. UBYTE md_hardchn=0,md_softchn=0;
  74. void (*md_player)(void) = Player_HandleTick;
  75. static BOOL  isplaying=0, initialized = 0;
  76. static UBYTE *sfxinfo;
  77. static int sfxpool;
  79. static SAMPLE **md_sample = NULL;
  81. /* Previous driver in use */
  82. static SWORD olddevice = -1;
  84. /* Limits the number of hardware voices to the specified amount.
  85.    This function should only be used by the low-level drivers. */
  86. static void LimitHardVoices(int limit)
  87. {
  88. int t=0;
  90. if (!(md_mode & DMODE_SOFT_SNDFX) && (md_sfxchn>limit)) md_sfxchn=limit;
  91. if (!(md_mode & DMODE_SOFT_MUSIC) && (md_sngchn>limit)) md_sngchn=limit;
  93. if (!(md_mode & DMODE_SOFT_SNDFX))
  94. md_hardchn=md_sfxchn;
  95. else
  96. md_hardchn=0;
  98. if (!(md_mode & DMODE_SOFT_MUSIC)) md_hardchn += md_sngchn;
  100. while (md_hardchn>limit) {
  101. if (++t & 1) {
  102. if (!(md_mode & DMODE_SOFT_SNDFX) && (md_sfxchn>4)) md_sfxchn--;
  103. } else {
  104. if (!(md_mode & DMODE_SOFT_MUSIC) && (md_sngchn>8)) md_sngchn--;
  105. }
  107. if (!(md_mode & DMODE_SOFT_SNDFX))
  108. md_hardchn=md_sfxchn;
  109. else
  110. md_hardchn=0;
  112. if (!(md_mode & DMODE_SOFT_MUSIC))
  113. md_hardchn+=md_sngchn;
  114. }
  115. md_numchn=md_hardchn+md_softchn;
  116. }
  118. /* Limits the number of hardware voices to the specified amount.
  119.    This function should only be used by the low-level drivers. */
  120. static void LimitSoftVoices(int limit)
  121. {
  122. int t=0;
  124. if ((md_mode & DMODE_SOFT_SNDFX) && (md_sfxchn>limit)) md_sfxchn=limit;
  125. if ((md_mode & DMODE_SOFT_MUSIC) && (md_sngchn>limit)) md_sngchn=limit;
  127. if (md_mode & DMODE_SOFT_SNDFX)
  128. md_softchn=md_sfxchn;
  129. else
  130. md_softchn=0;
  132. if (md_mode & DMODE_SOFT_MUSIC) md_softchn+=md_sngchn;
  134. while (md_softchn>limit) {
  135. if (++t & 1) {
  136. if ((md_mode & DMODE_SOFT_SNDFX) && (md_sfxchn>4)) md_sfxchn--;
  137. } else {
  138. if ((md_mode & DMODE_SOFT_MUSIC) && (md_sngchn>8)) md_sngchn--;
  139. }
  141. if (!(md_mode & DMODE_SOFT_SNDFX))
  142. md_softchn=md_sfxchn;
  143. else
  144. md_softchn=0;
  146. if (!(md_mode & DMODE_SOFT_MUSIC))
  147. md_softchn+=md_sngchn;
  148. }
  149. md_numchn=md_hardchn+md_softchn;
  150. }
  152. /* Note: 'type' indicates whether the returned value should be for music or for
  153.    sound effects. */
  154. ULONG MD_SampleSpace(int type)
  155. {
  156. if(type==MD_MUSIC)
  157. type=(md_mode & DMODE_SOFT_MUSIC)?MD_SOFTWARE:MD_HARDWARE;
  158. else if(type==MD_SNDFX)
  159. type=(md_mode & DMODE_SOFT_SNDFX)?MD_SOFTWARE:MD_HARDWARE;
  161. return md_driver->FreeSampleSpace(type);
  162. }
  164. ULONG MD_SampleLength(int type,SAMPLE* s)
  165. {
  166. if(type==MD_MUSIC)
  167. type=(md_mode & DMODE_SOFT_MUSIC)?MD_SOFTWARE:MD_HARDWARE;
  168. else
  169.   if(type==MD_SNDFX)
  170. type=(md_mode & DMODE_SOFT_SNDFX)?MD_SOFTWARE:MD_HARDWARE;
  172. return md_driver->RealSampleLength(type,s);
  173. }
  175. MIKMODAPI CHAR* MikMod_InfoDriver(void)
  176. {
  177. int t,len=0;
  178. MDRIVER *l;
  179. CHAR *list=NULL;
  181. MUTEX_LOCK(lists);
  182. /* compute size of buffer */
  183. for(l=firstdriver;l;l=l->next)
  184. len+=4+(l->next?1:0)+strlen(l->Version);
  186. if(len)
  187. if((list=_mm_malloc(len*sizeof(CHAR)))) {
  188. list[0]=0;
  189. /* list all registered device drivers : */
  190. for(t=1,l=firstdriver;l;l=l->next,t++)
  191. sprintf(list,(l->next)?"%s%2d %sn":"%s%2d %s",
  192.     list,t,l->Version);
  193. }
  194. MUTEX_UNLOCK(lists);
  195. return list;
  196. }
  198. void _mm_registerdriver(struct MDRIVER* drv)
  199. {
  200. MDRIVER *cruise = firstdriver;
  202. /* don't register a MISSING() driver */
  203. if ((drv->Name) && (drv->Version)) {
  204. if (cruise) {
  205. while (cruise->next) cruise = cruise->next;
  206. cruise->next = drv;
  207. } else
  208. firstdriver = drv; 
  209. }
  210. }
  212. MIKMODAPI void MikMod_RegisterDriver(struct MDRIVER* drv)
  213. {
  214. /* if we try to register an invalid driver, or an already registered driver,
  215.    ignore this attempt */
  216. if ((!drv)||(drv->next)||(!drv->Name))
  217. return;
  219. MUTEX_LOCK(lists);
  220. _mm_registerdriver(drv);
  221. MUTEX_UNLOCK(lists);
  222. }
  224. MIKMODAPI int MikMod_DriverFromAlias(CHAR *alias)
  225. {
  226. int rank=1;
  227. MDRIVER *cruise;
  229. MUTEX_LOCK(lists);
  230. cruise=firstdriver;
  231. while(cruise) {
  232. if (cruise->Alias) {
  233. if (!(strcasecmp(alias,cruise->Alias))) break;
  234. rank++;
  235. }
  236. cruise=cruise->next;
  237. }
  238. if(!cruise) rank=0;
  239. MUTEX_UNLOCK(lists);
  241. return rank;
  242. }
  244. MIKMODAPI MDRIVER *MikMod_DriverByOrdinal(int ordinal)
  245. {
  246.         MDRIVER *cruise;
  248.         /* Allow only driver ordinals > 0 */
  249.         if (!ordinal)
  250.                 return 0;
  252.         MUTEX_LOCK(lists);
  253.         cruise = firstdriver;
  254.         while (cruise && --ordinal)
  255.                 cruise = cruise->next;
  256.         MUTEX_UNLOCK(lists);
  257.         return cruise;
  258. }
  260. SWORD MD_SampleLoad(SAMPLOAD* s, int type)
  261. {
  262. SWORD result;
  264. if(type==MD_MUSIC)
  265. type=(md_mode & DMODE_SOFT_MUSIC)?MD_SOFTWARE:MD_HARDWARE;
  266. else if(type==MD_SNDFX)
  267. type=(md_mode & DMODE_SOFT_SNDFX)?MD_SOFTWARE:MD_HARDWARE;
  269. SL_Init(s);
  270. result=md_driver->SampleLoad(s,type);
  271. SL_Exit(s);
  273. return result;
  274. }
  276. void MD_SampleUnload(SWORD handle)
  277. {
  278. md_driver->SampleUnload(handle);
  279. }
  281. MIKMODAPI MikMod_player_t MikMod_RegisterPlayer(MikMod_player_t player)
  282. {
  283. MikMod_player_t result;
  285. MUTEX_LOCK(vars);
  286. result=md_player;
  287. md_player=player;
  288. MUTEX_UNLOCK(vars);
  290. return result;
  291. }
  293. MIKMODAPI void MikMod_Update(void)
  294. {
  295. MUTEX_LOCK(vars);
  296. if(isplaying) {
  297. if((!pf)||(!pf->forbid))
  298. md_driver->Update();
  299. else {
  300. if (md_driver->Pause)
  301. md_driver->Pause();
  302. }
  303. }
  304. MUTEX_UNLOCK(vars);
  305. }
  307. void Voice_SetVolume_internal(SBYTE voice,UWORD vol)
  308. {
  309. ULONG  tmp;
  311. if((voice<0)||(voice>=md_numchn)) return;
  313. /* range checks */
  314. if(md_musicvolume>128) md_musicvolume=128;
  315. if(md_sndfxvolume>128) md_sndfxvolume=128;
  316. if(md_volume>128) md_volume=128;
  318. tmp=(ULONG)vol*(ULONG)md_volume*
  319.      ((voice<md_sngchn)?(ULONG)md_musicvolume:(ULONG)md_sndfxvolume);
  320. md_driver->VoiceSetVolume(voice,tmp/16384UL);
  321. }
  323. MIKMODAPI void Voice_SetVolume(SBYTE voice,UWORD vol)
  324. {
  325. MUTEX_LOCK(vars);
  326. Voice_SetVolume_internal(voice,vol);
  327. MUTEX_UNLOCK(vars);
  328. }
  330. MIKMODAPI UWORD Voice_GetVolume(SBYTE voice)
  331. {
  332. UWORD result=0;
  334. MUTEX_LOCK(vars);
  335. if((voice>=0)&&(voice<md_numchn))
  336. result=md_driver->VoiceGetVolume(voice);
  337. MUTEX_UNLOCK(vars);
  339. return result;
  340. }
  342. void Voice_SetFrequency_internal(SBYTE voice,ULONG frq)
  343. {
  344. if((voice<0)||(voice>=md_numchn)) return;
  345. if((md_sample[voice])&&(md_sample[voice]->divfactor))
  346. frq/=md_sample[voice]->divfactor;
  347. md_driver->VoiceSetFrequency(voice,frq);
  348. }
  350. MIKMODAPI void Voice_SetFrequency(SBYTE voice,ULONG frq)
  351. {
  352. MUTEX_LOCK(vars);
  353. Voice_SetFrequency_internal(voice,frq);
  354. MUTEX_UNLOCK(vars);
  355. }
  357. MIKMODAPI ULONG Voice_GetFrequency(SBYTE voice)
  358. {
  359. ULONG result=0;
  361. MUTEX_LOCK(vars);
  362. if((voice>=0)&&(voice<md_numchn))
  363. result=md_driver->VoiceGetFrequency(voice);
  364. MUTEX_UNLOCK(vars);
  366. return result;
  367. }
  369. void Voice_SetPanning_internal(SBYTE voice,ULONG pan)
  370. {
  371. if((voice<0)||(voice>=md_numchn)) return;
  372. if(pan!=PAN_SURROUND) {
  373. if(md_pansep>128) md_pansep=128;
  374. if(md_mode & DMODE_REVERSE) pan=255-pan;
  375. pan = (((SWORD)(pan-128)*md_pansep)/128)+128;
  376. }
  377. md_driver->VoiceSetPanning(voice, pan);
  378. }
  380. MIKMODAPI void Voice_SetPanning(SBYTE voice,ULONG pan)
  381. {
  382. #ifdef MIKMOD_DEBUG
  383. if((pan!=PAN_SURROUND)&&((pan<0)||(pan>255)))
  384. fprintf(stderr,"rVoice_SetPanning called with pan=%ldn",(long)pan);
  385. #endif
  387. MUTEX_LOCK(vars);
  388. Voice_SetPanning_internal(voice,pan);
  389. MUTEX_UNLOCK(vars);
  390. }
  392. MIKMODAPI ULONG Voice_GetPanning(SBYTE voice)
  393. {
  394. ULONG result=PAN_CENTER;
  396. MUTEX_LOCK(vars);
  397. if((voice>=0)&&(voice<md_numchn))
  398. result=md_driver->VoiceGetPanning(voice);
  399. MUTEX_UNLOCK(vars);
  401. return result;
  402. }
  404. void Voice_Play_internal(SBYTE voice,SAMPLE* s,ULONG start)
  405. {
  406. ULONG  repend;
  408. if((voice<0)||(voice>=md_numchn)) return;
  410. md_sample[voice]=s;
  411. repend=s->loopend;
  413. if(s->flags&SF_LOOP)
  414. /* repend can't be bigger than size */
  415. if(repend>s->length) repend=s->length;
  417. md_driver->VoicePlay(voice,s->handle,start,s->length,s->loopstart,repend,s->flags);
  418. }
  420. MIKMODAPI void Voice_Play(SBYTE voice,SAMPLE* s,ULONG start)
  421. {
  422. if(start>s->length) return;
  424. MUTEX_LOCK(vars);
  425. Voice_Play_internal(voice,s,start);
  426. MUTEX_UNLOCK(vars);
  427. }
  429. void Voice_Stop_internal(SBYTE voice)
  430. {
  431. if((voice<0)||(voice>=md_numchn)) return;
  432. if(voice>=md_sngchn)
  433. /* It is a sound effects channel, so flag the voice as non-critical! */
  434. sfxinfo[voice-md_sngchn]=0;
  435. md_driver->VoiceStop(voice);
  436. }
  438. MIKMODAPI void Voice_Stop(SBYTE voice)
  439. {
  440. MUTEX_LOCK(vars);
  441. Voice_Stop_internal(voice);
  442. MUTEX_UNLOCK(vars);
  443. }
  445. BOOL Voice_Stopped_internal(SBYTE voice)
  446. {
  447. if((voice<0)||(voice>=md_numchn)) return 0;
  448. return(md_driver->VoiceStopped(voice));
  449. }
  451. MIKMODAPI BOOL Voice_Stopped(SBYTE voice)
  452. {
  453. BOOL result;
  455. MUTEX_LOCK(vars);
  456. result=Voice_Stopped_internal(voice);
  457. MUTEX_UNLOCK(vars);
  459. return result;
  460. }
  462. MIKMODAPI SLONG Voice_GetPosition(SBYTE voice)
  463. {
  464. SLONG result=0;
  466. MUTEX_LOCK(vars);
  467. if((voice>=0)&&(voice<md_numchn)) {
  468. if (md_driver->VoiceGetPosition)
  469. result=(md_driver->VoiceGetPosition(voice));
  470. else
  471. result=-1;
  472. }
  473. MUTEX_UNLOCK(vars);
  475. return result;
  476. }
  478. MIKMODAPI ULONG Voice_RealVolume(SBYTE voice)
  479. {
  480. ULONG result=0;
  482. MUTEX_LOCK(vars);
  483. if((voice>=0)&&(voice<md_numchn)&& md_driver->VoiceRealVolume)
  484. result=(md_driver->VoiceRealVolume(voice));
  485. MUTEX_UNLOCK(vars);
  487. return result;
  488. }
  490. static BOOL _mm_init(CHAR *cmdline)
  491. {
  492. UWORD t;
  494. _mm_critical = 1;
  496. /* if md_device==0, try to find a device number */
  497. if(!md_device) {
  498. cmdline=NULL;
  500. for(t=1,md_driver=firstdriver;md_driver;md_driver=md_driver->next,t++)
  501. if(md_driver->IsPresent()) break;
  503. if(!md_driver) {
  504. _mm_errno = MMERR_DETECTING_DEVICE;
  505. if(_mm_errorhandler) _mm_errorhandler();
  506. md_driver = &drv_nos;
  507. return 1;
  508. }
  510. md_device = t;
  511. } else {
  512. /* if n>0, use that driver */
  513. for(t=1,md_driver=firstdriver;(md_driver)&&(t!=md_device);md_driver=md_driver->next)
  514. t++;
  516. if(!md_driver) {
  517. _mm_errno = MMERR_INVALID_DEVICE;
  518. if(_mm_errorhandler) _mm_errorhandler();
  519. md_driver = &drv_nos;
  520. return 1;
  521. }
  523. /* arguments here might be necessary for the presence check to succeed */
  524. if(cmdline&&(md_driver->CommandLine))
  525. md_driver->CommandLine(cmdline);
  527. if(!md_driver->IsPresent()) {
  528. _mm_errno = MMERR_DETECTING_DEVICE;
  529. if(_mm_errorhandler) _mm_errorhandler();
  530. md_driver = &drv_nos;
  531. return 1;
  532. }
  533. }
  535. olddevice = md_device;
  536. if(md_driver->Init()) {
  537. MikMod_Exit_internal();
  538. if(_mm_errorhandler) _mm_errorhandler();
  539. return 1;
  540. }
  542. initialized=1;
  543. _mm_critical=0;
  545. return 0;
  546. }
  548. MIKMODAPI BOOL MikMod_Init(CHAR *cmdline)
  549. {
  550. BOOL result;
  552. MUTEX_LOCK(vars);
  553. MUTEX_LOCK(lists);
  554. result=_mm_init(cmdline);
  555. MUTEX_UNLOCK(lists);
  556. MUTEX_UNLOCK(vars);
  558. return result;
  559. }
  561. void MikMod_Exit_internal(void)
  562. {
  563. MikMod_DisableOutput_internal();
  564. md_driver->Exit();
  565. md_numchn = md_sfxchn = md_sngchn = 0;
  566. md_driver = &drv_nos;
  568. if(sfxinfo) free(sfxinfo);
  569. if(md_sample) free(md_sample);
  570. md_sample  = NULL;
  571. sfxinfo    = NULL;
  573. initialized = 0;
  574. }
  576. MIKMODAPI void MikMod_Exit(void)
  577. {
  578. MUTEX_LOCK(vars);
  579. MUTEX_LOCK(lists);
  580. MikMod_Exit_internal();
  581. MUTEX_UNLOCK(lists);
  582. MUTEX_UNLOCK(vars);
  583. }
  585. /* Reset the driver using the new global variable settings. 
  586.    If the driver has not been initialized, it will be now. */
  587. static BOOL _mm_reset(CHAR *cmdline)
  588. {
  589. BOOL wasplaying = 0;
  591. if(!initialized) return _mm_init(cmdline);
  593. if (isplaying) {
  594. wasplaying = 1;
  595. md_driver->PlayStop();
  596. }
  598. if((!md_driver->Reset)||(md_device != olddevice)) {
  599. /* md_driver->Reset was NULL, or md_device was changed, so do a full
  600.    reset of the driver. */
  601. md_driver->Exit();
  602. if(_mm_init(cmdline)) {
  603. MikMod_Exit_internal();
  604. if(_mm_errno)
  605. if(_mm_errorhandler) _mm_errorhandler();
  606. return 1;
  607. }
  608. } else {
  609. if(md_driver->Reset()) {
  610. MikMod_Exit_internal();
  611. if(_mm_errno)
  612. if(_mm_errorhandler) _mm_errorhandler();
  613. return 1;
  614. }
  615. }
  617. if (wasplaying) md_driver->PlayStart();
  618. return 0;
  619. }
  621. MIKMODAPI BOOL MikMod_Reset(CHAR *cmdline)
  622. {
  623. BOOL result;
  625. MUTEX_LOCK(vars);
  626. MUTEX_LOCK(lists);
  627. result=_mm_reset(cmdline);
  628. MUTEX_UNLOCK(lists);
  629. MUTEX_UNLOCK(vars);
  631. return result;
  632. }
  634. /* If either parameter is -1, the current set value will be retained. */
  635. BOOL MikMod_SetNumVoices_internal(int music, int sfx)
  636. {
  637. BOOL resume = 0;
  638. int t, oldchn = 0;
  640. if((!music)&&(!sfx)) return 1;
  641. _mm_critical = 1;
  642. if(isplaying) {
  643. MikMod_DisableOutput_internal();
  644. oldchn = md_numchn;
  645. resume = 1;
  646. }
  648. if(sfxinfo) free(sfxinfo);
  649. if(md_sample) free(md_sample);
  650. md_sample  = NULL;
  651. sfxinfo    = NULL;
  653. if(music!=-1) md_sngchn = music;
  654. if(sfx!=-1)   md_sfxchn = sfx;
  655. md_numchn = md_sngchn + md_sfxchn;
  657. LimitHardVoices(md_driver->HardVoiceLimit);
  658. LimitSoftVoices(md_driver->SoftVoiceLimit);
  660. if(md_driver->SetNumVoices()) {
  661. MikMod_Exit_internal();
  662. if(_mm_errno)
  663. if(_mm_errorhandler!=NULL) _mm_errorhandler();
  664. md_numchn = md_softchn = md_hardchn = md_sfxchn = md_sngchn = 0;
  665. return 1;
  666. }
  668. if(md_sngchn+md_sfxchn)
  669. md_sample=(SAMPLE**)_mm_calloc(md_sngchn+md_sfxchn,sizeof(SAMPLE*));
  670. if(md_sfxchn)
  671. sfxinfo = (UBYTE *)_mm_calloc(md_sfxchn,sizeof(UBYTE));
  673. /* make sure the player doesn't start with garbage */
  674. for(t=oldchn;t<md_numchn;t++)  Voice_Stop_internal(t);
  676. sfxpool = 0;
  677. if(resume) MikMod_EnableOutput_internal();
  678. _mm_critical = 0;
  680. return 0;
  681. }
  683. MIKMODAPI BOOL MikMod_SetNumVoices(int music, int sfx)
  684. {
  685. BOOL result;
  687. MUTEX_LOCK(vars);
  688. result=MikMod_SetNumVoices_internal(music,sfx);
  689. MUTEX_UNLOCK(vars);
  691. return result;
  692. }
  694. BOOL MikMod_EnableOutput_internal(void)
  695. {
  696. _mm_critical = 1;
  697. if(!isplaying) {
  698. if(md_driver->PlayStart()) return 1;
  699. isplaying = 1;
  700. }
  701. _mm_critical = 0;
  702. return 0;
  703. }
  705. MIKMODAPI BOOL MikMod_EnableOutput(void)
  706. {
  707. BOOL result;
  709. MUTEX_LOCK(vars);
  710. result=MikMod_EnableOutput_internal();
  711. MUTEX_UNLOCK(vars);
  713. return result;
  714. }
  716. void MikMod_DisableOutput_internal(void)
  717. {
  718. if(isplaying && md_driver) {
  719. isplaying = 0;
  720. md_driver->PlayStop();
  721. }
  722. }
  724. MIKMODAPI void MikMod_DisableOutput(void)
  725. {
  726. MUTEX_LOCK(vars);
  727. MikMod_DisableOutput_internal();
  728. MUTEX_UNLOCK(vars);
  729. }
  731. BOOL MikMod_Active_internal(void)
  732. {
  733. return isplaying;
  734. }
  736. MIKMODAPI BOOL MikMod_Active(void)
  737. {
  738. BOOL result;
  740. MUTEX_LOCK(vars);
  741. result=MikMod_Active_internal();
  742. MUTEX_UNLOCK(vars);
  744. return result;
  745. }
  747. /* Plays a sound effects sample.  Picks a voice from the number of voices
  748.    allocated for use as sound effects (loops through voices, skipping all active
  749.    criticals).
  751.    Returns the voice that the sound is being played on.                       */
  752. SBYTE Sample_Play_internal(SAMPLE *s,ULONG start,UBYTE flags)
  753. {
  754. int orig=sfxpool;/* for cases where all channels are critical */
  755. int c;
  757. if(!md_sfxchn) return -1;
  758. if(s->volume>64) s->volume = 64;
  760. /* check the first location after sfxpool */
  761. do {
  762. if(sfxinfo[sfxpool]&SFX_CRITICAL) {
  763. if(md_driver->VoiceStopped(c=sfxpool+md_sngchn)) {
  764. sfxinfo[sfxpool]=flags;
  765. Voice_Play_internal(c,s,start);
  766. md_driver->VoiceSetVolume(c,s->volume<<2);
  767. Voice_SetPanning_internal(c,s->panning);
  768. md_driver->VoiceSetFrequency(c,s->speed);
  769. sfxpool++;
  770. if(sfxpool>=md_sfxchn) sfxpool=0;
  771. return c;
  772. }
  773. } else {
  774. sfxinfo[sfxpool]=flags;
  775. Voice_Play_internal(c=sfxpool+md_sngchn,s,start);
  776. md_driver->VoiceSetVolume(c,s->volume<<2);
  777. Voice_SetPanning_internal(c,s->panning);
  778. md_driver->VoiceSetFrequency(c,s->speed);
  779. sfxpool++;
  780. if(sfxpool>=md_sfxchn) sfxpool=0;
  781. return c;
  782. }
  784. sfxpool++;
  785. if(sfxpool>=md_sfxchn) sfxpool = 0;
  786. } while(sfxpool!=orig);
  788. return -1;
  789. }
  791. MIKMODAPI SBYTE Sample_Play(SAMPLE *s,ULONG start,UBYTE flags)
  792. {
  793. SBYTE result;
  795. MUTEX_LOCK(vars);
  796. result=Sample_Play_internal(s,start,flags);
  797. MUTEX_UNLOCK(vars);
  799. return result;
  800. }
  802. MIKMODAPI long MikMod_GetVersion(void)
  803. {
  804. return LIBMIKMOD_VERSION;
  805. }
  807. /*========== MT-safe stuff */
  809. #ifdef HAVE_PTHREAD
  810. #define INIT_MUTEX(name) 
  811. pthread_mutex_t _mm_mutex_##name=PTHREAD_MUTEX_INITIALIZER
  812. #elif defined(__OS2__)||defined(__EMX__)
  813. #define INIT_MUTEX(name) 
  814. HMTX _mm_mutex_##name
  815. #elif defined(WIN32)
  816. #define INIT_MUTEX(name) 
  817. HANDLE _mm_mutex_##name
  818. #else
  819. #define INIT_MUTEX(name) 
  820. void *_mm_mutex_##name = NULL
  821. #endif
  823. INIT_MUTEX(vars);
  824. INIT_MUTEX(lists);
  826. MIKMODAPI BOOL MikMod_InitThreads(void)
  827. {
  828. static int firstcall=1;
  829. static int result=0;
  831. if (firstcall) {
  832. firstcall=0;
  833. #ifdef HAVE_PTHREAD
  834. result=1;
  835. #elif defined(__OS2__)||defined(__EMX__)
  836. if(DosCreateMutexSem((PSZ)NULL,&_mm_mutex_lists,0,0) ||
  837.    DosCreateMutexSem((PSZ)NULL,&_mm_mutex_vars,0,0)) {
  838. _mm_mutex_lists=_mm_mutex_vars=(HMTX)NULL;
  839. result=0;
  840. } else
  841. result=1;
  842. #elif defined(WIN32)
  843. if((!(_mm_mutex_lists=CreateMutex(NULL,FALSE,"libmikmod(lists)")))||
  844.    (!(_mm_mutex_vars=CreateMutex(NULL,FALSE,"libmikmod(vars)"))))
  845. result=0;
  846. else
  847. result=1;
  848. #endif
  849. }
  850. return result;
  851. }
  853. MIKMODAPI void MikMod_Unlock(void)
  854. {
  855. MUTEX_UNLOCK(lists);
  856. MUTEX_UNLOCK(vars);
  857. }
  859. MIKMODAPI void MikMod_Lock(void)
  860. {
  861. MUTEX_LOCK(vars);
  862. MUTEX_LOCK(lists);
  863. }
  865. /*========== Parameter extraction helper */
  867. CHAR *MD_GetAtom(CHAR *atomname,CHAR *cmdline,BOOL implicit)
  868. {
  869. CHAR *ret=NULL;
  871. if(cmdline) {
  872. CHAR *buf=strstr(cmdline,atomname);
  874. if((buf)&&((buf==cmdline)||(*(buf-1)==','))) {
  875. CHAR *ptr=buf+strlen(atomname);
  877. if(*ptr=='=') {
  878. for(buf=++ptr;(*ptr)&&((*ptr)!=',');ptr++);
  879. ret=_mm_malloc((1+ptr-buf)*sizeof(CHAR));
  880. if(ret)
  881. strncpy(ret,buf,ptr-buf);
  882. } else if((*ptr==',')||(!*ptr)) {
  883. if(implicit) {
  884. ret=_mm_malloc((1+ptr-buf)*sizeof(CHAR));
  885. if(ret)
  886. strncpy(ret,buf,ptr-buf);
  887. }
  888. }
  889. }
  890. }
  891. return ret;
  892. }
  894. #if defined unix || (defined __APPLE__ && defined __MACH__)
  896. /*========== Posix helper functions */
  898. /* Check if the file is a regular or nonexistant file (or a link to a such a
  899.    file), and that, should the calling program be setuid, the access rights are
  900.    reasonable. Returns 1 if it is safe to rewrite the file, 0 otherwise.
  901.    The goal is to prevent a setuid root libmikmod application from overriding
  902.    files like /etc/passwd with digital sound... */
  903. BOOL MD_Access(CHAR *filename)
  904. {
  905. struct stat buf;
  907. if(!stat(filename,&buf)) {
  908. /* not a regular file ? */
  909. if(!S_ISREG(buf.st_mode)) return 0;
  910. /* more than one hard link to the file ? */
  911. if(buf.st_nlink>1) return 0;
  912. /* check access rights with the real user and group id */
  913. if(getuid()==buf.st_uid) {
  914. if(!(buf.st_mode&S_IWUSR)) return 0;
  915. } else if(getgid()==buf.st_gid) {
  916. if(!(buf.st_mode&S_IWGRP)) return 0;
  917. } else
  918. if(!(buf.st_mode&S_IWOTH)) return 0;
  919. }
  921. return 1;
  922. }
  924. /* Drop all root privileges we might have */
  925. BOOL MD_DropPrivileges(void)
  926. {
  927. if(!geteuid()) {
  928. if(getuid()) {
  929. /* we are setuid root -> drop setuid to become the real user */
  930. if(setuid(getuid())) return 1;
  931. } else {
  932. /* we are run as root -> drop all and become user 'nobody' */
  933. struct passwd *nobody;
  934. int uid;
  936. if(!(nobody=getpwnam("nobody"))) return 1; /* no such user ? */
  937. uid=nobody->pw_uid;
  938. if (!uid) /* user 'nobody' has root privileges ? weird... */
  939. return 1;
  940. if (setuid(uid)) return 1;
  941. }
  942. }
  943. return 0;
  944. }
  946. #endif
  948. /* ex:set ts=4: */