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

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

Windows CE

开发平台：

C/C++

drv_alsa.c：源码内容
  1. /* MikMod sound library
  2. (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for
  3. 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: drv_alsa.c,v 1.2 2004/01/31 22:39:40 raph Exp $
  25.   Driver for Advanced Linux Sound Architecture (ALSA)
  27. ==============================================================================*/
  29. #ifdef HAVE_CONFIG_H
  30. #include "config.h"
  31. #endif
  33. #include "mikmod_internals.h"
  35. #ifdef DRV_ALSA
  37. #ifdef HAVE_UNISTD_H
  38. #include <unistd.h>
  39. #endif
  40. #ifdef HAVE_MEMORY_H
  41. #include <memory.h>
  42. #endif
  44. #ifdef MIKMOD_DYNAMIC
  45. #include <dlfcn.h>
  46. #endif
  47. #include <stdlib.h>
  48. #include <string.h>
  50. #include <sys/asoundlib.h>
  51. #if defined(SND_LIB_VERSION) && (SND_LIB_VERSION >= 0x500)
  52. #undef DRV_ALSA
  53. #endif
  55. #endif
  56. #ifdef DRV_ALSA
  58. #ifdef MIKMOD_DYNAMIC
  59. /* runtime link with libasound */
  60. static unsigned int(*alsa_cards_mask)(void);
  61. static int(*alsa_ctl_close)(snd_ctl_t*);
  62. static int(*alsa_ctl_hw_info)(snd_ctl_t*,struct snd_ctl_hw_info*);
  63. static int(*alsa_ctl_open)(snd_ctl_t**,int);
  64. static int(*alsa_ctl_pcm_info)(snd_ctl_t*,int,snd_pcm_info_t*);
  65. #if defined(SND_LIB_VERSION) && (SND_LIB_VERSION >= 0x400)
  66. static int(*alsa_ctl_pcm_playback_info)(snd_ctl_t*,int,int,snd_pcm_playback_info_t*);
  67. #else
  68. static int(*alsa_ctl_pcm_playback_info)(snd_ctl_t*,int,snd_pcm_playback_info_t*);
  69. #endif
  70. static int(*alsa_pcm_close)(snd_pcm_t*);
  71. static int(*alsa_pcm_drain_playback)(snd_pcm_t*);
  72. static int(*alsa_pcm_flush_playback)(snd_pcm_t*);
  73. static int(*alsa_pcm_open)(snd_pcm_t**,int,int,int);
  74. static int(*alsa_pcm_playback_format)(snd_pcm_t*,snd_pcm_format_t*);
  75. static int(*alsa_pcm_playback_info)(snd_pcm_t*,snd_pcm_playback_info_t*);
  76. static int(*alsa_pcm_playback_params)(snd_pcm_t*,snd_pcm_playback_params_t*);
  77. static int(*alsa_pcm_playback_status)(snd_pcm_t*,snd_pcm_playback_status_t*);
  78. static int(*alsa_pcm_write)(snd_pcm_t*,const void*,size_t);
  79. static void* libasound=NULL;
  80. #ifndef HAVE_RTLD_GLOBAL
  81. #define RTLD_GLOBAL (0)
  82. #endif
  83. #else
  84. /* compile-time link with libasound */
  85. #define alsa_cards_mask snd_cards_mask
  86. #define alsa_ctl_close snd_ctl_close
  87. #define alsa_ctl_hw_info snd_ctl_hw_info
  88. #define alsa_ctl_open snd_ctl_open
  89. #define alsa_ctl_pcm_info snd_ctl_pcm_info
  90. #define alsa_ctl_pcm_playback_info snd_ctl_pcm_playback_info
  91. #define alsa_pcm_close snd_pcm_close
  92. #define alsa_pcm_drain_playback snd_pcm_drain_playback
  93. #define alsa_pcm_flush_playback snd_pcm_flush_playback
  94. #define alsa_pcm_open snd_pcm_open
  95. #define alsa_pcm_playback_format snd_pcm_playback_format
  96. #define alsa_pcm_playback_info snd_pcm_playback_info
  97. #define alsa_pcm_playback_params snd_pcm_playback_params
  98. #define alsa_pcm_playback_status snd_pcm_playback_status
  99. #define alsa_pcm_write snd_pcm_write
  100. #endif /* MIKMOD_DYNAMIC */
  102. #define DEFAULT_NUMFRAGS 4
  104. static snd_pcm_t *pcm_h=NULL;
  105. static int fragmentsize,numfrags=DEFAULT_NUMFRAGS;
  106. static SBYTE *audiobuffer=NULL;
  107. static int cardmin=0,cardmax=SND_CARDS;
  108. static int device=-1;
  110. #ifdef MIKMOD_DYNAMIC
  111. static BOOL ALSA_Link(void)
  112. {
  113. if(libasound) return 0;
  115. /* load libasound.so */
  116. libasound=dlopen("libasound.so",RTLD_LAZY|RTLD_GLOBAL);
  117. if(!libasound) return 1;
  119. /* resolve function references */
  120. if(!(alsa_cards_mask           =dlsym(libasound,"snd_cards_mask"))) return 1;
  121. if(!(alsa_ctl_close            =dlsym(libasound,"snd_ctl_close"))) return 1;
  122. if(!(alsa_ctl_hw_info          =dlsym(libasound,"snd_ctl_hw_info"))) return 1;
  123. if(!(alsa_ctl_open             =dlsym(libasound,"snd_ctl_open"))) return 1;
  124. if(!(alsa_ctl_pcm_info         =dlsym(libasound,"snd_ctl_pcm_info"))) return 1;
  125. if(!(alsa_ctl_pcm_playback_info=dlsym(libasound,"snd_ctl_pcm_playback_info"))) return 1;
  126. if(!(alsa_pcm_close            =dlsym(libasound,"snd_pcm_close"))) return 1;
  127. if(!(alsa_pcm_drain_playback   =dlsym(libasound,"snd_pcm_drain_playback"))) return 1;
  128. if(!(alsa_pcm_flush_playback   =dlsym(libasound,"snd_pcm_flush_playback"))) return 1;
  129. if(!(alsa_pcm_open             =dlsym(libasound,"snd_pcm_open"))) return 1;
  130. if(!(alsa_pcm_playback_format  =dlsym(libasound,"snd_pcm_playback_format"))) return 1;
  131. if(!(alsa_pcm_playback_info    =dlsym(libasound,"snd_pcm_playback_info"))) return 1;
  132. if(!(alsa_pcm_playback_params  =dlsym(libasound,"snd_pcm_playback_params"))) return 1;
  133. if(!(alsa_pcm_playback_status  =dlsym(libasound,"snd_pcm_playback_status"))) return 1;
  134. if(!(alsa_pcm_write            =dlsym(libasound,"snd_pcm_write"))) return 1;
  136. return 0;
  137. }
  139. static void ALSA_Unlink(void)
  140. {
  141. alsa_cards_mask           =NULL;
  142. alsa_ctl_close            =NULL;
  143. alsa_ctl_hw_info          =NULL;
  144. alsa_ctl_open             =NULL;
  145. alsa_ctl_pcm_info         =NULL;
  146. alsa_ctl_pcm_playback_info=NULL;
  147. alsa_pcm_close            =NULL;
  148. alsa_pcm_drain_playback   =NULL;
  149. alsa_pcm_flush_playback   =NULL;
  150. alsa_pcm_open             =NULL;
  151. alsa_pcm_playback_format  =NULL;
  152. alsa_pcm_playback_info    =NULL;
  153. alsa_pcm_playback_params  =NULL;
  154. alsa_pcm_playback_status  =NULL;
  155. alsa_pcm_write            =NULL;
  157. if(libasound) {
  158. dlclose(libasound);
  159. libasound=NULL;
  160. }
  161. }
  162. #endif /* MIKMOD_DYNAMIC */
  164. static void ALSA_CommandLine(CHAR *cmdline)
  165. {
  166. CHAR *ptr;
  168. if((ptr=MD_GetAtom("card",cmdline,0))) {
  169. cardmin=atoi(ptr);cardmax=cardmin+1;
  170. free(ptr);
  171. } else {
  172. cardmin=0;cardmax=SND_CARDS;
  173. }
  174. if((ptr=MD_GetAtom("pcm",cmdline,0))) {
  175. device=atoi(ptr);
  176. free(ptr);
  177. } else device=-1;
  178. if((ptr=MD_GetAtom("buffer",cmdline,0))) {
  179. numfrags=atoi(ptr);
  180. if ((numfrags<2)||(numfrags>16)) numfrags=DEFAULT_NUMFRAGS;
  181. free(ptr);
  182. } else numfrags=DEFAULT_NUMFRAGS;
  183. }
  185. static BOOL ALSA_IsThere(void)
  186. {
  187. int retval;
  189. #ifdef MIKMOD_DYNAMIC
  190. if (ALSA_Link()) return 0;
  191. #endif
  192. retval=(alsa_cards_mask())?1:0;
  193. #ifdef MIKMOD_DYNAMIC
  194. ALSA_Unlink();
  195. #endif
  196. return retval;
  197. }
  199. static BOOL ALSA_Init_internal(void)
  200. {
  201. snd_pcm_format_t pformat;
  202. int mask,card;
  204. /* adjust user-configurable settings */
  205. if((getenv("MM_NUMFRAGS"))&&(numfrags==DEFAULT_NUMFRAGS)) {
  206. numfrags=atoi(getenv("MM_NUMFRAGS"));
  207. if ((numfrags<2)||(numfrags>16)) numfrags=DEFAULT_NUMFRAGS;
  208. }
  209. if((getenv("ALSA_CARD"))&&(!cardmin)&&(cardmax==SND_CARDS)) {
  210. cardmin=atoi(getenv("ALSA_CARD"));
  211. cardmax=cardmin+1;
  212. if(getenv("ALSA_PCM"))
  213. device=atoi(getenv("ALSA_PCM"));
  214. }
  216. /* setup playback format structure */
  217. memset(&pformat,0,sizeof(pformat));
  218. #ifdef SND_LITTLE_ENDIAN
  219. pformat.format=(md_mode&DMODE_16BITS)?SND_PCM_SFMT_S16_LE:SND_PCM_SFMT_U8;
  220. #else
  221. pformat.format=(md_mode&DMODE_16BITS)?SND_PCM_SFMT_S16_BE:SND_PCM_SFMT_U8;
  222. #endif
  223. pformat.channels=(md_mode&DMODE_STEREO)?2:1;
  224. pformat.rate=md_mixfreq;
  226. /* scan for appropriate sound card */
  227. mask=alsa_cards_mask();
  228. _mm_errno=MMERR_OPENING_AUDIO;
  229. for (card=cardmin;card<cardmax;card++) {
  230. struct snd_ctl_hw_info info;
  231. snd_ctl_t *ctl_h;
  232. int dev,devmin,devmax;
  234. /* no card here, onto the next */
  235. if (!(mask&(1<<card))) continue;
  237. /* try to open the card in query mode */
  238. if(alsa_ctl_open(&ctl_h,card)<0)
  239. continue;
  241. /* get hardware information */
  242. if(alsa_ctl_hw_info(ctl_h,&info)<0) {
  243. alsa_ctl_close(ctl_h);
  244. continue;
  245. }
  247. /* scan subdevices */
  248. if(device==-1) {
  249. devmin=0;devmax=info.pcmdevs;
  250. } else
  251. devmin=devmax=device;
  252. for(dev=devmin;dev<devmax;dev++) {
  253. snd_pcm_info_t pcminfo;
  254. snd_pcm_playback_info_t ctlinfo;
  255. struct snd_pcm_playback_info pinfo;
  256. struct snd_pcm_playback_params pparams;
  257. int size,bps;
  259. /* get PCM capabilities */
  260. if(alsa_ctl_pcm_info(ctl_h,dev,&pcminfo)<0)
  261. continue;
  263. /* look for playback capability */
  264. if(!(pcminfo.flags&SND_PCM_INFO_PLAYBACK))
  265. continue;
  267. /* get playback information */
  268. #if defined(SND_LIB_VERSION) && (SND_LIB_VERSION >= 0x400)
  269. if(alsa_ctl_pcm_playback_info(ctl_h,dev,0,&ctlinfo)<0)
  270. continue;
  271. #else
  272. if(alsa_ctl_pcm_playback_info(ctl_h,dev,&ctlinfo)<0)
  273. continue;
  274. #endif
  276. /*
  277.    If control goes here, we have found a sound device able to play PCM data.
  278.    Let's open in in playback mode and see if we have compatible playback
  279.    settings.
  280. */
  282. if (alsa_pcm_open(&pcm_h,card,dev,SND_PCM_OPEN_PLAYBACK)<0)
  283. continue;
  285. if (alsa_pcm_playback_info(pcm_h,&pinfo)<0) {
  286. alsa_pcm_close(pcm_h);
  287. pcm_h=NULL;
  288. continue;
  289. }
  291. /* check we have compatible settings */
  292. if((pinfo.min_rate>pformat.rate)||(pinfo.max_rate<pformat.rate)||
  293.    (!(pinfo.formats&(1<<pformat.format)))) {
  294. alsa_pcm_close(pcm_h);
  295. pcm_h=NULL;
  296. continue;
  297. }
  299. fragmentsize=pinfo.buffer_size/numfrags;
  300. #ifdef MIKMOD_DEBUG
  301. if ((fragmentsize<512)||(fragmentsize>16777216L))
  302. fprintf(stderr,"rweird pinfo.buffer_size:%dn",pinfo.buffer_size);
  303. #endif
  305. alsa_pcm_flush_playback(pcm_h);
  307. /* set new parameters */
  308. if(alsa_pcm_playback_format(pcm_h,&pformat)<0) {
  309. alsa_pcm_close(pcm_h);
  310. pcm_h=NULL;
  311. continue;
  312. }
  314. /* compute a fragmentsize hint
  315.    each fragment should be shorter than, but close to, half a
  316.    second of playback */
  317. bps=(pformat.rate*pformat.channels*(md_mode&DMODE_16BITS?2:1))>>1;
  318. size=fragmentsize;while (size>bps) size>>=1;
  319. #ifdef MIKMOD_DEBUG
  320. if (size < 16) {
  321. fprintf(stderr,"rweird hint result:%d from %d, bps=%dn",size,fragmentsize,bps);
  322. size=16;
  323. }
  324. #endif
  326. memset(&pparams,0,sizeof(pparams));
  327. pparams.fragment_size=size;
  328. pparams.fragments_max=-1; /* choose the best */
  329. pparams.fragments_room=-1;
  330. if(alsa_pcm_playback_params(pcm_h,&pparams)<0) {
  331. alsa_pcm_close(pcm_h);
  332. pcm_h=NULL;
  333. continue;
  334. }
  336. if (!(audiobuffer=(SBYTE*)_mm_malloc(fragmentsize))) {
  337. alsa_ctl_close(ctl_h);
  338. return 1;
  339. }
  341. /* sound device is ready to work */
  342. if (VC_Init()) {
  343. alsa_ctl_close(ctl_h);
  344. return 1;
  345. } else
  346.   return 0;
  347. }
  349. alsa_ctl_close(ctl_h);
  350. }
  351. return 1;
  352. }
  354. static BOOL ALSA_Init(void)
  355. {
  356. #ifdef MIKMOD_DYNAMIC
  357. if (ALSA_Link()) {
  358. _mm_errno=MMERR_DYNAMIC_LINKING;
  359. return 1;
  360. }
  361. #endif
  362. return ALSA_Init_internal();
  363. }
  365. static void ALSA_Exit_internal(void)
  366. {
  367. VC_Exit();
  368. if (pcm_h) {
  369. alsa_pcm_drain_playback(pcm_h);
  370. alsa_pcm_close(pcm_h);
  371. pcm_h=NULL;
  372. }
  373. _mm_free(audiobuffer);
  374. }
  376. static void ALSA_Exit(void)
  377. {
  378. ALSA_Exit_internal();
  379. #ifdef MIKMOD_DYNAMIC
  380. ALSA_Unlink();
  381. #endif
  382. }
  384. static void ALSA_Update(void)
  385. {
  386. snd_pcm_playback_status_t status;
  387. int total, count;
  389. if (alsa_pcm_playback_status(pcm_h, &status) >= 0) {
  390. /* Update md_mixfreq if necessary */
  391. if (md_mixfreq != status.rate)
  392. md_mixfreq = status.rate;
  394. /* Using status.count would cause clicks, as this is always less than
  395.    the freespace  in the buffer - so compute how many bytes we can
  396.    afford */
  397. total = status.fragments * status.fragment_size - status.queue;
  398. if (total < fragmentsize)
  399. total = fragmentsize;
  400. } else
  401. total = fragmentsize;
  403. /* Don't send data if ALSA is too busy */
  404. while (total) {
  405. count = fragmentsize > total ? total : fragmentsize;
  406. total -= count;
  407. alsa_pcm_write(pcm_h,audiobuffer,VC_WriteBytes(audiobuffer,count));
  408. }
  409. }
  411. static void ALSA_PlayStop(void)
  412. {
  413. VC_PlayStop();
  415. alsa_pcm_flush_playback(pcm_h);
  416. }
  418. static BOOL ALSA_Reset(void)
  419. {
  420. ALSA_Exit_internal();
  421. return ALSA_Init_internal();
  422. }
  424. MIKMODAPI MDRIVER drv_alsa={
  425. NULL,
  426. "ALSA",
  427. "Advanced Linux Sound Architecture (ALSA) driver v0.4",
  428. 0,255,
  429. "alsa",
  430. "card:r:0,31,0:Soundcard numbern"
  431.         "pcm:r:0,3,0:PCM device numbern"
  432.         "buffer:r:2,16,4:Number of buffer fragmentsn",
  433. ALSA_CommandLine,
  434. ALSA_IsThere,
  435. VC_SampleLoad,
  436. VC_SampleUnload,
  437. VC_SampleSpace,
  438. VC_SampleLength,
  439. ALSA_Init,
  440. ALSA_Exit,
  441. ALSA_Reset,
  442. VC_SetNumVoices,
  443. VC_PlayStart,
  444. ALSA_PlayStop,
  445. ALSA_Update,
  446. NULL,
  447. VC_VoiceSetVolume,
  448. VC_VoiceGetVolume,
  449. VC_VoiceSetFrequency,
  450. VC_VoiceGetFrequency,
  451. VC_VoiceSetPanning,
  452. VC_VoiceGetPanning,
  453. VC_VoicePlay,
  454. VC_VoiceStop,
  455. VC_VoiceStopped,
  456. VC_VoiceGetPosition,
  457. VC_VoiceRealVolume
  458. };
  460. #else
  462. MISSING(drv_alsa);
  464. #endif
  466. /* ex:set ts=4: */