audio.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591
  1. /* -*- mode: c; tab-width: 4; c-basic-offset: 4; c-file-style: "linux" -*- */
  2. //
  3. // Copyright (c) 2009-2011, Wei Mingzhi <whistler_wmz@users.sf.net>.
  4. // Copyright (c) 2011-2017, SDLPAL development team.
  5. // All rights reserved.
  6. //
  7. // This file is part of SDLPAL.
  8. //
  9. // SDLPAL is free software: you can redistribute it and/or modify
  10. // it under the terms of the GNU General Public License as published by
  11. // the Free Software Foundation, either version 3 of the License, or
  12. // (at your option) any later version.
  13. //
  14. // This program 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
  17. // GNU General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public License
  20. // along with this program. If not, see <http://www.gnu.org/licenses/>.
  21. //
  22. #include "palcommon.h"
  23. #include "global.h"
  24. #include "palcfg.h"
  25. #include "audio.h"
  26. #include "players.h"
  27. #include "util.h"
  28. #include "resampler.h"
  29. #include "midi.h"
  30. #include <math.h>
  31. #if PAL_HAS_OGG
  32. #include <vorbis/codec.h>
  33. #endif
  34. #define PAL_CDTRACK_BASE 10000
  35. typedef void(*ResampleMixFunction)(void *, const void *, int, void *, int, int, uint8_t);
  36. typedef struct tagAUDIODEVICE
  37. {
  38. SDL_AudioSpec spec; /* Actual-used sound specification */
  39. SDL_AudioCVT cvt; /* Audio format conversion parameter */
  40. AUDIOPLAYER *pMusPlayer;
  41. AUDIOPLAYER *pCDPlayer;
  42. #if PAL_HAS_SDLCD
  43. SDL_CD *pCD;
  44. #endif
  45. AUDIOPLAYER *pSoundPlayer;
  46. void *pSoundBuffer; /* The output buffer for sound */
  47. INT iMusicVolume; /* The BGM volume ranged in [0, 128] for better performance */
  48. INT iSoundVolume; /* The sound effect volume ranged in [0, 128] for better performance */
  49. BOOL fMusicEnabled; /* Is BGM enabled? */
  50. BOOL fSoundEnabled; /* Is sound effect enabled? */
  51. BOOL fOpened; /* Is the audio device opened? */
  52. } AUDIODEVICE;
  53. static AUDIODEVICE gAudioDevice;
  54. PAL_FORCE_INLINE
  55. void
  56. AUDIO_MixNative(
  57. short *dst,
  58. short *src,
  59. int samples
  60. )
  61. {
  62. while (samples > 0)
  63. {
  64. int val = *src++ + *dst;
  65. if (val > SHRT_MAX)
  66. *dst++ = SHRT_MAX;
  67. else if (val < SHRT_MIN)
  68. *dst++ = SHRT_MIN;
  69. else
  70. *dst++ = (short)val;
  71. samples--;
  72. }
  73. }
  74. PAL_FORCE_INLINE
  75. void
  76. AUDIO_AdjustVolume(
  77. short *srcdst,
  78. int iVolume,
  79. int samples
  80. )
  81. {
  82. if (iVolume == SDL_MIX_MAXVOLUME) return;
  83. if (iVolume == 0) { memset(srcdst, 0, samples << 1); return; }
  84. while (samples > 0)
  85. {
  86. *srcdst = *srcdst * iVolume / SDL_MIX_MAXVOLUME;
  87. samples--; srcdst++;
  88. }
  89. }
  90. static VOID SDLCALL
  91. AUDIO_FillBuffer(
  92. LPVOID udata,
  93. LPBYTE stream,
  94. INT len
  95. )
  96. /*++
  97. Purpose:
  98. SDL sound callback function.
  99. Parameters:
  100. [IN] udata - pointer to user-defined parameters (Not used).
  101. [OUT] stream - pointer to the stream buffer.
  102. [IN] len - Length of the buffer.
  103. Return value:
  104. None.
  105. --*/
  106. {
  107. memset(stream, 0, len);
  108. gAudioDevice.cvt.buf = stream;
  109. gAudioDevice.cvt.len = len;
  110. //
  111. // Play music
  112. //
  113. if (gAudioDevice.fMusicEnabled && gAudioDevice.iMusicVolume > 0)
  114. {
  115. if (gAudioDevice.pMusPlayer)
  116. {
  117. gAudioDevice.pMusPlayer->FillBuffer(gAudioDevice.pMusPlayer, stream, len);
  118. }
  119. if (gAudioDevice.pCDPlayer)
  120. {
  121. gAudioDevice.pCDPlayer->FillBuffer(gAudioDevice.pCDPlayer, stream, len);
  122. }
  123. //
  124. // Adjust volume for music
  125. //
  126. AUDIO_AdjustVolume((short *)stream, gAudioDevice.iMusicVolume, len >> 1);
  127. }
  128. //
  129. // Play sound
  130. //
  131. if (gAudioDevice.fSoundEnabled && gAudioDevice.pSoundPlayer && gAudioDevice.iSoundVolume > 0)
  132. {
  133. memset(gAudioDevice.pSoundBuffer, 0, len);
  134. gAudioDevice.pSoundPlayer->FillBuffer(gAudioDevice.pSoundPlayer, gAudioDevice.pSoundBuffer, len);
  135. //
  136. // Adjust volume for sound
  137. //
  138. AUDIO_AdjustVolume((short *)gAudioDevice.pSoundBuffer, gAudioDevice.iSoundVolume, len >> 1);
  139. //
  140. // Mix sound & music
  141. //
  142. AUDIO_MixNative((short *)stream, gAudioDevice.pSoundBuffer, len >> 1);
  143. }
  144. //
  145. // Convert audio from native byte-order to actual byte-order
  146. //
  147. SDL_ConvertAudio(&gAudioDevice.cvt);
  148. }
  149. INT
  150. AUDIO_OpenDevice(
  151. VOID
  152. )
  153. /*++
  154. Purpose:
  155. Initialize the audio subsystem.
  156. Parameters:
  157. None.
  158. Return value:
  159. 0 if succeed, others if failed.
  160. --*/
  161. {
  162. SDL_AudioSpec spec;
  163. if (gAudioDevice.fOpened)
  164. {
  165. //
  166. // Already opened
  167. //
  168. return -1;
  169. }
  170. #ifdef __EMSCRIPTEN__ // Now either music/sound enabled will makes whole app crash in emscripten. Disabled until a solution is found.
  171. return -1;
  172. #endif
  173. gAudioDevice.fOpened = FALSE;
  174. gAudioDevice.fMusicEnabled = TRUE;
  175. gAudioDevice.fSoundEnabled = TRUE;
  176. gAudioDevice.iMusicVolume = gConfig.iMusicVolume * SDL_MIX_MAXVOLUME / PAL_MAX_VOLUME;
  177. gAudioDevice.iSoundVolume = gConfig.iSoundVolume * SDL_MIX_MAXVOLUME / PAL_MAX_VOLUME;
  178. //
  179. // Initialize the resampler module
  180. //
  181. resampler_init();
  182. //
  183. // Open the audio device.
  184. //
  185. gAudioDevice.spec.freq = gConfig.iSampleRate;
  186. gAudioDevice.spec.format = AUDIO_S16;
  187. gAudioDevice.spec.channels = gConfig.iAudioChannels;
  188. gAudioDevice.spec.samples = gConfig.wAudioBufferSize;
  189. gAudioDevice.spec.callback = AUDIO_FillBuffer;
  190. if (SDL_OpenAudio(&gAudioDevice.spec, &spec) < 0)
  191. {
  192. //
  193. // Failed
  194. //
  195. return -3;
  196. }
  197. else
  198. {
  199. gAudioDevice.spec = spec;
  200. gAudioDevice.pSoundBuffer = malloc(spec.size);
  201. }
  202. SDL_BuildAudioCVT(&gAudioDevice.cvt, AUDIO_S16SYS, spec.channels, spec.freq, spec.format, spec.channels, spec.freq);
  203. gAudioDevice.fOpened = TRUE;
  204. //
  205. // Initialize the sound subsystem.
  206. //
  207. gAudioDevice.pSoundPlayer = SOUND_Init();
  208. //
  209. // Initialize the music subsystem.
  210. //
  211. switch (gConfig.eMusicType)
  212. {
  213. case MUSIC_RIX:
  214. if (!(gAudioDevice.pMusPlayer = RIX_Init(va("%s%s", gConfig.pszGamePath, "mus.mkf"))))
  215. {
  216. gAudioDevice.pMusPlayer = RIX_Init(va("%s%s", gConfig.pszGamePath, "MUS.MKF"));
  217. }
  218. break;
  219. case MUSIC_MP3:
  220. gAudioDevice.pMusPlayer = MP3_Init();
  221. break;
  222. case MUSIC_OGG:
  223. gAudioDevice.pMusPlayer = OGG_Init();
  224. break;
  225. case MUSIC_MIDI:
  226. gAudioDevice.pMusPlayer = NULL;
  227. break;
  228. default:
  229. break;
  230. }
  231. //
  232. // Initialize the CD audio.
  233. //
  234. switch (gConfig.eCDType)
  235. {
  236. case MUSIC_SDLCD:
  237. {
  238. #if PAL_HAS_SDLCD
  239. int i;
  240. gAudioDevice.pCD = NULL;
  241. for (i = 0; i < SDL_CDNumDrives(); i++)
  242. {
  243. gAudioDevice.pCD = SDL_CDOpen(i);
  244. if (gAudioDevice.pCD != NULL)
  245. {
  246. if (!CD_INDRIVE(SDL_CDStatus(gAudioDevice.pCD)))
  247. {
  248. SDL_CDClose(gAudioDevice.pCD);
  249. gAudioDevice.pCD = NULL;
  250. }
  251. else
  252. {
  253. break;
  254. }
  255. }
  256. }
  257. #endif
  258. gAudioDevice.pCDPlayer = NULL;
  259. break;
  260. }
  261. case MUSIC_MP3:
  262. gAudioDevice.pCDPlayer = MP3_Init();
  263. break;
  264. case MUSIC_OGG:
  265. gAudioDevice.pCDPlayer = OGG_Init();
  266. break;
  267. default:
  268. break;
  269. }
  270. //
  271. // Let the callback function run so that musics will be played.
  272. //
  273. SDL_PauseAudio(0);
  274. return 0;
  275. }
  276. VOID
  277. AUDIO_CloseDevice(
  278. VOID
  279. )
  280. /*++
  281. Purpose:
  282. Close the audio subsystem.
  283. Parameters:
  284. None.
  285. Return value:
  286. None.
  287. --*/
  288. {
  289. SDL_CloseAudio();
  290. if (gAudioDevice.pSoundPlayer != NULL)
  291. {
  292. gAudioDevice.pSoundPlayer->Shutdown(gAudioDevice.pSoundPlayer);
  293. gAudioDevice.pSoundPlayer = NULL;
  294. }
  295. if (gAudioDevice.pMusPlayer)
  296. {
  297. gAudioDevice.pMusPlayer->Shutdown(gAudioDevice.pMusPlayer);
  298. gAudioDevice.pMusPlayer = NULL;
  299. }
  300. if (gAudioDevice.pCDPlayer)
  301. {
  302. gAudioDevice.pCDPlayer->Shutdown(gAudioDevice.pCDPlayer);
  303. gAudioDevice.pCDPlayer = NULL;
  304. }
  305. #if PAL_HAS_SDLCD
  306. if (gAudioDevice.pCD != NULL)
  307. {
  308. AUDIO_PlayCDTrack(-1);
  309. SDL_CDClose(gAudioDevice.pCD);
  310. }
  311. #endif
  312. if (gAudioDevice.pSoundBuffer != NULL)
  313. {
  314. free(gAudioDevice.pSoundBuffer);
  315. gAudioDevice.pSoundBuffer = NULL;
  316. }
  317. if (gConfig.eMusicType == MUSIC_MIDI)
  318. {
  319. MIDI_Play(0, FALSE);
  320. }
  321. }
  322. SDL_AudioSpec*
  323. AUDIO_GetDeviceSpec(
  324. VOID
  325. )
  326. {
  327. return &gAudioDevice.spec;
  328. }
  329. static INT
  330. AUDIO_ChangeVolumeByValue(
  331. INT *iVolume,
  332. INT iValue
  333. )
  334. {
  335. *iVolume += iValue;
  336. if (*iVolume > PAL_MAX_VOLUME)
  337. *iVolume = PAL_MAX_VOLUME;
  338. else if (*iVolume < 0)
  339. *iVolume = 0;
  340. return *iVolume;
  341. }
  342. VOID
  343. AUDIO_IncreaseVolume(
  344. VOID
  345. )
  346. /*++
  347. Purpose:
  348. Increase global volume by 3%.
  349. Parameters:
  350. None.
  351. Return value:
  352. None.
  353. --*/
  354. {
  355. AUDIO_ChangeVolumeByValue(&gConfig.iMusicVolume, 3);
  356. AUDIO_ChangeVolumeByValue(&gConfig.iSoundVolume, 3);
  357. gAudioDevice.iMusicVolume = gConfig.iMusicVolume * SDL_MIX_MAXVOLUME / PAL_MAX_VOLUME;
  358. gAudioDevice.iSoundVolume = gConfig.iSoundVolume * SDL_MIX_MAXVOLUME / PAL_MAX_VOLUME;
  359. }
  360. VOID
  361. AUDIO_DecreaseVolume(
  362. VOID
  363. )
  364. /*++
  365. Purpose:
  366. Decrease global volume by 3%.
  367. Parameters:
  368. None.
  369. Return value:
  370. None.
  371. --*/
  372. {
  373. AUDIO_ChangeVolumeByValue(&gConfig.iMusicVolume, -3);
  374. AUDIO_ChangeVolumeByValue(&gConfig.iSoundVolume, -3);
  375. gAudioDevice.iMusicVolume = gConfig.iMusicVolume * SDL_MIX_MAXVOLUME / PAL_MAX_VOLUME;
  376. gAudioDevice.iSoundVolume = gConfig.iSoundVolume * SDL_MIX_MAXVOLUME / PAL_MAX_VOLUME;
  377. }
  378. VOID
  379. AUDIO_PlaySound(
  380. INT iSoundNum
  381. )
  382. /*++
  383. Purpose:
  384. Play a sound in voc.mkf/sounds.mkf file.
  385. Parameters:
  386. [IN] iSoundNum - number of the sound; the absolute value is used.
  387. Return value:
  388. None.
  389. --*/
  390. {
  391. // Unlike musics that use the 'load as required' strategy, sound player
  392. // load the entire sound file at once, which may cause about 0.5s or longer
  393. // latency for large sound files. To prevent this latency affects audio playing,
  394. // the mutex lock is obtained inside the SOUND_Play function rather than here.
  395. if (gAudioDevice.pSoundPlayer)
  396. {
  397. gAudioDevice.pSoundPlayer->Play(gAudioDevice.pSoundPlayer, abs(iSoundNum), FALSE, 0.0f);
  398. }
  399. }
  400. VOID
  401. AUDIO_PlayMusic(
  402. INT iNumRIX,
  403. BOOL fLoop,
  404. FLOAT flFadeTime
  405. )
  406. {
  407. if (gConfig.eMusicType == MUSIC_MIDI)
  408. {
  409. MIDI_Play(iNumRIX, fLoop);
  410. return;
  411. }
  412. SDL_LockAudio();
  413. if (gAudioDevice.pMusPlayer)
  414. {
  415. gAudioDevice.pMusPlayer->Play(gAudioDevice.pMusPlayer, iNumRIX, fLoop, flFadeTime);
  416. }
  417. SDL_UnlockAudio();
  418. }
  419. BOOL
  420. AUDIO_PlayCDTrack(
  421. INT iNumTrack
  422. )
  423. /*++
  424. Purpose:
  425. Play a CD Audio Track.
  426. Parameters:
  427. [IN] iNumTrack - number of the CD Audio Track.
  428. Return value:
  429. TRUE if the track can be played, FALSE if not.
  430. --*/
  431. {
  432. BOOL ret = FALSE;
  433. #if PAL_HAS_SDLCD
  434. if (gAudioDevice.pCD != NULL)
  435. {
  436. if (CD_INDRIVE(SDL_CDStatus(gAudioDevice.pCD)))
  437. {
  438. SDL_CDStop(gAudioDevice.pCD);
  439. if (iNumTrack != -1)
  440. {
  441. AUDIO_PlayMusic(-1, FALSE, 0);
  442. if (SDL_CDPlayTracks(gAudioDevice.pCD, iNumTrack - 1, 0, 1, 0) == 0)
  443. {
  444. return TRUE;
  445. }
  446. }
  447. }
  448. }
  449. #endif
  450. SDL_LockAudio();
  451. if (gAudioDevice.pCDPlayer)
  452. {
  453. if (iNumTrack != -1)
  454. {
  455. AUDIO_PlayMusic(-1, FALSE, 0);
  456. ret = gAudioDevice.pCDPlayer->Play(gAudioDevice.pCDPlayer, PAL_CDTRACK_BASE + iNumTrack, TRUE, 0);
  457. }
  458. else
  459. {
  460. ret = gAudioDevice.pCDPlayer->Play(gAudioDevice.pCDPlayer, -1, FALSE, 0);
  461. }
  462. }
  463. SDL_UnlockAudio();
  464. return ret;
  465. }
  466. VOID
  467. AUDIO_EnableMusic(
  468. BOOL fEnable
  469. )
  470. {
  471. gAudioDevice.fMusicEnabled = fEnable;
  472. }
  473. BOOL
  474. AUDIO_MusicEnabled(
  475. VOID
  476. )
  477. {
  478. return gAudioDevice.fMusicEnabled;
  479. }
  480. VOID
  481. AUDIO_EnableSound(
  482. BOOL fEnable
  483. )
  484. {
  485. gAudioDevice.fSoundEnabled = fEnable;
  486. }
  487. BOOL
  488. AUDIO_SoundEnabled(
  489. VOID
  490. )
  491. {
  492. return gAudioDevice.fSoundEnabled;
  493. }