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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
sndfile-play.c
资源名称：libsndfile-1.0.21.tar.gz　[点击查看]
上传用户：shw771010
上传日期：2022-01-05
资源大小：991k
文件大小：27k
源码类别：

Audio

开发平台：

Unix_Linux

sndfile-play.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2009 Erik de Castro Lopo <erikd@mega-nerd.com>
  3. **
  4. ** All rights reserved.
  5. **
  6. ** Redistribution and use in source and binary forms, with or without
  7. ** modification, are permitted provided that the following conditions are
  8. ** met:
  9. **
  10. **     * Redistributions of source code must retain the above copyright
  11. **       notice, this list of conditions and the following disclaimer.
  12. **     * Redistributions in binary form must reproduce the above copyright
  13. **       notice, this list of conditions and the following disclaimer in
  14. **       the documentation and/or other materials provided with the
  15. **       distribution.
  16. **     * Neither the author nor the names of any contributors may be used
  17. **       to endorse or promote products derived from this software without
  18. **       specific prior written permission.
  19. **
  20. ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21. ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22. ** TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23. ** PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  24. ** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25. ** EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26. ** PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  27. ** OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28. ** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29. ** OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  30. ** ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31. */
  33. #include "sfconfig.h"
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  38. #include <errno.h>
  40. #if HAVE_UNISTD_H
  41. #include <unistd.h>
  42. #endif
  44. #if HAVE_ALSA_ASOUNDLIB_H
  45. #define ALSA_PCM_NEW_HW_PARAMS_API
  46. #define ALSA_PCM_NEW_SW_PARAMS_API
  47. #include <alsa/asoundlib.h>
  48. #include <sys/time.h>
  49. #endif
  51. #if defined (__linux__) || defined (__FreeBSD_kernel__) || defined (__FreeBSD__)
  52. #include  <fcntl.h>
  53. #include  <sys/ioctl.h>
  54. #include  <sys/soundcard.h>
  56. #elif (defined (__MACH__) && defined (__APPLE__))
  57. #include <Carbon.h>
  58. #include <CoreAudio/AudioHardware.h>
  60. #elif (defined (sun) && defined (unix))
  61. #include <fcntl.h>
  62. #include <sys/ioctl.h>
  63. #include <sys/audioio.h>
  65. #elif (OS_IS_WIN32 == 1)
  66. #include <windows.h>
  67. #include <mmsystem.h>
  69. #endif
  71. #include <sndfile.h>
  73. #define SIGNED_SIZEOF(x) ((int) sizeof (x))
  74. #define BUFFER_LEN (2048)
  76. /*------------------------------------------------------------------------------
  77. ** Linux/OSS functions for playing a sound.
  78. */
  80. #if HAVE_ALSA_ASOUNDLIB_H
  82. static snd_pcm_t * alsa_open (int channels, unsigned srate, int realtime) ;
  83. static int alsa_write_float (snd_pcm_t *alsa_dev, float *data, int frames, int channels) ;
  85. static void
  86. alsa_play (int argc, char *argv [])
  87. { static float buffer [BUFFER_LEN] ;
  88. SNDFILE *sndfile ;
  89. SF_INFO sfinfo ;
  90. snd_pcm_t * alsa_dev ;
  91. int k, readcount, subformat ;
  93. for (k = 1 ; k < argc ; k++)
  94. { memset (&sfinfo, 0, sizeof (sfinfo)) ;
  96. printf ("Playing %sn", argv [k]) ;
  97. if (! (sndfile = sf_open (argv [k], SFM_READ, &sfinfo)))
  98. { puts (sf_strerror (NULL)) ;
  99. continue ;
  100. } ;
  102. if (sfinfo.channels < 1 || sfinfo.channels > 2)
  103. { printf ("Error : channels = %d.n", sfinfo.channels) ;
  104. continue ;
  105. } ;
  107. if ((alsa_dev = alsa_open (sfinfo.channels, (unsigned) sfinfo.samplerate, SF_FALSE)) == NULL)
  108. continue ;
  110. subformat = sfinfo.format & SF_FORMAT_SUBMASK ;
  112. if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
  113. { double scale ;
  114. int  m ;
  116. sf_command (sndfile, SFC_CALC_SIGNAL_MAX, &scale, sizeof (scale)) ;
  117. if (scale < 1e-10)
  118. scale = 1.0 ;
  119. else
  120. scale = 32700.0 / scale ;
  122. while ((readcount = sf_read_float (sndfile, buffer, BUFFER_LEN)))
  123. { for (m = 0 ; m < readcount ; m++)
  124. buffer [m] *= scale ;
  125. alsa_write_float (alsa_dev, buffer, BUFFER_LEN / sfinfo.channels, sfinfo.channels) ;
  126. } ;
  127. }
  128. else
  129. { while ((readcount = sf_read_float (sndfile, buffer, BUFFER_LEN)))
  130. alsa_write_float (alsa_dev, buffer, BUFFER_LEN / sfinfo.channels, sfinfo.channels) ;
  131. } ;
  133. snd_pcm_drain (alsa_dev) ;
  134. snd_pcm_close (alsa_dev) ;
  136. sf_close (sndfile) ;
  137. } ;
  139. return ;
  140. } /* alsa_play */
  142. static snd_pcm_t *
  143. alsa_open (int channels, unsigned samplerate, int realtime)
  144. { const char * device = "default" ;
  145. snd_pcm_t *alsa_dev = NULL ;
  146. snd_pcm_hw_params_t *hw_params ;
  147. snd_pcm_uframes_t buffer_size ;
  148. snd_pcm_uframes_t alsa_period_size, alsa_buffer_frames ;
  149. snd_pcm_sw_params_t *sw_params ;
  151. int err ;
  153. if (realtime)
  154. { alsa_period_size = 256 ;
  155. alsa_buffer_frames = 3 * alsa_period_size ;
  156. }
  157. else
  158. { alsa_period_size = 1024 ;
  159. alsa_buffer_frames = 4 * alsa_period_size ;
  160. } ;
  162. if ((err = snd_pcm_open (&alsa_dev, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0)
  163. { fprintf (stderr, "cannot open audio device "%s" (%s)n", device, snd_strerror (err)) ;
  164. goto catch_error ;
  165. } ;
  167. snd_pcm_nonblock (alsa_dev, 0) ;
  169. if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0)
  170. { fprintf (stderr, "cannot allocate hardware parameter structure (%s)n", snd_strerror (err)) ;
  171. goto catch_error ;
  172. } ;
  174. if ((err = snd_pcm_hw_params_any (alsa_dev, hw_params)) < 0)
  175. { fprintf (stderr, "cannot initialize hardware parameter structure (%s)n", snd_strerror (err)) ;
  176. goto catch_error ;
  177. } ;
  179. if ((err = snd_pcm_hw_params_set_access (alsa_dev, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
  180. { fprintf (stderr, "cannot set access type (%s)n", snd_strerror (err)) ;
  181. goto catch_error ;
  182. } ;
  184. if ((err = snd_pcm_hw_params_set_format (alsa_dev, hw_params, SND_PCM_FORMAT_FLOAT)) < 0)
  185. { fprintf (stderr, "cannot set sample format (%s)n", snd_strerror (err)) ;
  186. goto catch_error ;
  187. } ;
  189. if ((err = snd_pcm_hw_params_set_rate_near (alsa_dev, hw_params, &samplerate, 0)) < 0)
  190. { fprintf (stderr, "cannot set sample rate (%s)n", snd_strerror (err)) ;
  191. goto catch_error ;
  192. } ;
  194. if ((err = snd_pcm_hw_params_set_channels (alsa_dev, hw_params, channels)) < 0)
  195. { fprintf (stderr, "cannot set channel count (%s)n", snd_strerror (err)) ;
  196. goto catch_error ;
  197. } ;
  199. if ((err = snd_pcm_hw_params_set_buffer_size_near (alsa_dev, hw_params, &alsa_buffer_frames)) < 0)
  200. { fprintf (stderr, "cannot set buffer size (%s)n", snd_strerror (err)) ;
  201. goto catch_error ;
  202. } ;
  204. if ((err = snd_pcm_hw_params_set_period_size_near (alsa_dev, hw_params, &alsa_period_size, 0)) < 0)
  205. { fprintf (stderr, "cannot set period size (%s)n", snd_strerror (err)) ;
  206. goto catch_error ;
  207. } ;
  209. if ((err = snd_pcm_hw_params (alsa_dev, hw_params)) < 0)
  210. { fprintf (stderr, "cannot set parameters (%s)n", snd_strerror (err)) ;
  211. goto catch_error ;
  212. } ;
  214. /* extra check: if we have only one period, this code won't work */
  215. snd_pcm_hw_params_get_period_size (hw_params, &alsa_period_size, 0) ;
  216. snd_pcm_hw_params_get_buffer_size (hw_params, &buffer_size) ;
  217. if (alsa_period_size == buffer_size)
  218. { fprintf (stderr, "Can't use period equal to buffer size (%lu == %lu)", alsa_period_size, buffer_size) ;
  219. goto catch_error ;
  220. } ;
  222. snd_pcm_hw_params_free (hw_params) ;
  224. if ((err = snd_pcm_sw_params_malloc (&sw_params)) != 0)
  225. { fprintf (stderr, "%s: snd_pcm_sw_params_malloc: %s", __func__, snd_strerror (err)) ;
  226. goto catch_error ;
  227. } ;
  229. if ((err = snd_pcm_sw_params_current (alsa_dev, sw_params)) != 0)
  230. { fprintf (stderr, "%s: snd_pcm_sw_params_current: %s", __func__, snd_strerror (err)) ;
  231. goto catch_error ;
  232. } ;
  234. /* note: set start threshold to delay start until the ring buffer is full */
  235. snd_pcm_sw_params_current (alsa_dev, sw_params) ;
  237. if ((err = snd_pcm_sw_params_set_start_threshold (alsa_dev, sw_params, buffer_size)) < 0)
  238. { fprintf (stderr, "cannot set start threshold (%s)n", snd_strerror (err)) ;
  239. goto catch_error ;
  240. } ;
  242. if ((err = snd_pcm_sw_params (alsa_dev, sw_params)) != 0)
  243. { fprintf (stderr, "%s: snd_pcm_sw_params: %s", __func__, snd_strerror (err)) ;
  244. goto catch_error ;
  245. } ;
  247. snd_pcm_sw_params_free (sw_params) ;
  249. snd_pcm_reset (alsa_dev) ;
  251. catch_error :
  253. if (err < 0 && alsa_dev != NULL)
  254. { snd_pcm_close (alsa_dev) ;
  255. return NULL ;
  256. } ;
  258. return alsa_dev ;
  259. } /* alsa_open */
  261. static int
  262. alsa_write_float (snd_pcm_t *alsa_dev, float *data, int frames, int channels)
  263. { static int epipe_count = 0 ;
  265. int total = 0 ;
  266. int retval ;
  268. if (epipe_count > 0)
  269. epipe_count -- ;
  271. while (total < frames)
  272. { retval = snd_pcm_writei (alsa_dev, data + total * channels, frames - total) ;
  274. if (retval >= 0)
  275. { total += retval ;
  276. if (total == frames)
  277. return total ;
  279. continue ;
  280. } ;
  282. switch (retval)
  283. { case -EAGAIN :
  284. puts ("alsa_write_float: EAGAIN") ;
  285. continue ;
  286. break ;
  288. case -EPIPE :
  289. if (epipe_count > 0)
  290. { printf ("alsa_write_float: EPIPE %dn", epipe_count) ;
  291. if (epipe_count > 140)
  292. return retval ;
  293. } ;
  294. epipe_count += 100 ;
  296. #if 0
  297. if (0)
  298. { snd_pcm_status_t *status ;
  300. snd_pcm_status_alloca (&status) ;
  301. if ((retval = snd_pcm_status (alsa_dev, status)) < 0)
  302. fprintf (stderr, "alsa_out: xrun. can't determine lengthn") ;
  303. else if (snd_pcm_status_get_state (status) == SND_PCM_STATE_XRUN)
  304. { struct timeval now, diff, tstamp ;
  306. gettimeofday (&now, 0) ;
  307. snd_pcm_status_get_trigger_tstamp (status, &tstamp) ;
  308. timersub (&now, &tstamp, &diff) ;
  310. fprintf (stderr, "alsa_write_float xrun: of at least %.3f msecs. resetting streamn",
  311. diff.tv_sec * 1000 + diff.tv_usec / 1000.0) ;
  312. }
  313. else
  314. fprintf (stderr, "alsa_write_float: xrun. can't determine lengthn") ;
  315. } ;
  316. #endif
  318. snd_pcm_prepare (alsa_dev) ;
  319. break ;
  321. case -EBADFD :
  322. fprintf (stderr, "alsa_write_float: Bad PCM state.n") ;
  323. return 0 ;
  324. break ;
  326. case -ESTRPIPE :
  327. fprintf (stderr, "alsa_write_float: Suspend event.n") ;
  328. return 0 ;
  329. break ;
  331. case -EIO :
  332. puts ("alsa_write_float: EIO") ;
  333. return 0 ;
  335. default :
  336. fprintf (stderr, "alsa_write_float: retval = %dn", retval) ;
  337. return 0 ;
  338. break ;
  339. } ; /* switch */
  340. } ; /* while */
  342. return total ;
  343. } /* alsa_write_float */
  345. #endif /* HAVE_ALSA_ASOUNDLIB_H */
  347. /*------------------------------------------------------------------------------
  348. ** Linux/OSS functions for playing a sound.
  349. */
  351. #if defined (__linux__) || defined (__FreeBSD_kernel__) || defined (__FreeBSD__)
  353. static int opensoundsys_open_device (int channels, int srate) ;
  355. static void
  356. opensoundsys_play (int argc, char *argv [])
  357. { static short buffer [BUFFER_LEN] ;
  358. SNDFILE *sndfile ;
  359. SF_INFO sfinfo ;
  360. int k, audio_device, readcount, writecount, subformat ;
  362. for (k = 1 ; k < argc ; k++)
  363. { memset (&sfinfo, 0, sizeof (sfinfo)) ;
  365. printf ("Playing %sn", argv [k]) ;
  366. if (! (sndfile = sf_open (argv [k], SFM_READ, &sfinfo)))
  367. { puts (sf_strerror (NULL)) ;
  368. continue ;
  369. } ;
  371. if (sfinfo.channels < 1 || sfinfo.channels > 2)
  372. { printf ("Error : channels = %d.n", sfinfo.channels) ;
  373. continue ;
  374. } ;
  376. audio_device = opensoundsys_open_device (sfinfo.channels, sfinfo.samplerate) ;
  378. subformat = sfinfo.format & SF_FORMAT_SUBMASK ;
  380. if (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE)
  381. { static float float_buffer [BUFFER_LEN] ;
  382. double scale ;
  383. int  m ;
  385. sf_command (sndfile, SFC_CALC_SIGNAL_MAX, &scale, sizeof (scale)) ;
  386. if (scale < 1e-10)
  387. scale = 1.0 ;
  388. else
  389. scale = 32700.0 / scale ;
  391. while ((readcount = sf_read_float (sndfile, float_buffer, BUFFER_LEN)))
  392. { for (m = 0 ; m < readcount ; m++)
  393. buffer [m] = scale * float_buffer [m] ;
  394. writecount = write (audio_device, buffer, readcount * sizeof (short)) ;
  395. } ;
  396. }
  397. else
  398. { while ((readcount = sf_read_short (sndfile, buffer, BUFFER_LEN)))
  399. writecount = write (audio_device, buffer, readcount * sizeof (short)) ;
  400. } ;
  402. if (ioctl (audio_device, SNDCTL_DSP_POST, 0) == -1)
  403. perror ("ioctl (SNDCTL_DSP_POST) ") ;
  405. if (ioctl (audio_device, SNDCTL_DSP_SYNC, 0) == -1)
  406. perror ("ioctl (SNDCTL_DSP_SYNC) ") ;
  408. close (audio_device) ;
  410. sf_close (sndfile) ;
  411. } ;
  413. return ;
  414. } /* opensoundsys_play */
  416. static int
  417. opensoundsys_open_device (int channels, int srate)
  418. { int fd, stereo, fmt ;
  420. if ((fd = open ("/dev/dsp", O_WRONLY, 0)) == -1 &&
  421. (fd = open ("/dev/sound/dsp", O_WRONLY, 0)) == -1)
  422. { perror ("opensoundsys_open_device : open ") ;
  423. exit (1) ;
  424. } ;
  426. stereo = 0 ;
  427. if (ioctl (fd, SNDCTL_DSP_STEREO, &stereo) == -1)
  428. {  /* Fatal error */
  429. perror ("opensoundsys_open_device : stereo ") ;
  430. exit (1) ;
  431. } ;
  433. if (ioctl (fd, SNDCTL_DSP_RESET, 0))
  434. { perror ("opensoundsys_open_device : reset ") ;
  435. exit (1) ;
  436. } ;
  438. fmt = CPU_IS_BIG_ENDIAN ? AFMT_S16_BE : AFMT_S16_LE ;
  439. if (ioctl (fd, SNDCTL_DSP_SETFMT, &fmt) != 0)
  440. { perror ("opensoundsys_open_device : set format ") ;
  441. exit (1) ;
  442.    } ;
  444. if (ioctl (fd, SNDCTL_DSP_CHANNELS, &channels) != 0)
  445. { perror ("opensoundsys_open_device : channels ") ;
  446. exit (1) ;
  447. } ;
  449. if (ioctl (fd, SNDCTL_DSP_SPEED, &srate) != 0)
  450. { perror ("opensoundsys_open_device : sample rate ") ;
  451. exit (1) ;
  452. } ;
  454. if (ioctl (fd, SNDCTL_DSP_SYNC, 0) != 0)
  455. { perror ("opensoundsys_open_device : sync ") ;
  456. exit (1) ;
  457. } ;
  459. return  fd ;
  460. } /* opensoundsys_open_device */
  462. #endif /* __linux__ */
  464. /*------------------------------------------------------------------------------
  465. ** Mac OS X functions for playing a sound.
  466. */
  468. #if (defined (__MACH__) && defined (__APPLE__)) /* MacOSX */
  470. typedef struct
  471. { AudioStreamBasicDescription format ;
  473. UInt32  buf_size ;
  474. AudioDeviceID  device ;
  476. SNDFILE  *sndfile ;
  477. SF_INFO  sfinfo ;
  479. int fake_stereo ;
  480. int done_playing ;
  481. } MacOSXAudioData ;
  483. #include <math.h>
  485. static OSStatus
  486. macosx_audio_out_callback (AudioDeviceID device, const AudioTimeStamp* current_time,
  487. const AudioBufferList* data_in, const AudioTimeStamp* time_in,
  488. AudioBufferList* data_out, const AudioTimeStamp* time_out,
  489. void* client_data)
  490. { MacOSXAudioData *audio_data ;
  491. int size, sample_count, read_count, k ;
  492. float *buffer ;
  494. /* Prevent compiler warnings. */
  495. device = device ;
  496. current_time = current_time ;
  497. data_in = data_in ;
  498. time_in = time_in ;
  499. time_out = time_out ;
  501. audio_data = (MacOSXAudioData*) client_data ;
  503. size = data_out->mBuffers [0].mDataByteSize ;
  504. sample_count = size / sizeof (float) ;
  506. buffer = (float*) data_out->mBuffers [0].mData ;
  508. if (audio_data->fake_stereo != 0)
  509. { read_count = sf_read_float (audio_data->sndfile, buffer, sample_count / 2) ;
  511. for (k = read_count - 1 ; k >= 0 ; k--)
  512. { buffer [2 * k ] = buffer [k] ;
  513. buffer [2 * k + 1] = buffer [k] ;
  514. } ;
  515. read_count *= 2 ;
  516. }
  517. else
  518. read_count = sf_read_float (audio_data->sndfile, buffer, sample_count) ;
  520. /* Fill the remainder with zeroes. */
  521. if (read_count < sample_count)
  522. { if (audio_data->fake_stereo == 0)
  523. memset (&(buffer [read_count]), 0, (sample_count - read_count) * sizeof (float)) ;
  524. /* Tell the main application to terminate. */
  525. audio_data->done_playing = SF_TRUE ;
  526. } ;
  528. return noErr ;
  529. } /* macosx_audio_out_callback */
  531. static void
  532. macosx_play (int argc, char *argv [])
  533. { MacOSXAudioData  audio_data ;
  534. OSStatus err ;
  535. UInt32 count, buffer_size ;
  536. int  k ;
  538. audio_data.fake_stereo = 0 ;
  539. audio_data.device = kAudioDeviceUnknown ;
  541. /*  get the default output device for the HAL */
  542. count = sizeof (AudioDeviceID) ;
  543. if ((err = AudioHardwareGetProperty (kAudioHardwarePropertyDefaultOutputDevice,
  544. &count, (void *) &(audio_data.device))) != noErr)
  545. { printf ("AudioHardwareGetProperty (kAudioDevicePropertyDefaultOutputDevice) failed.n") ;
  546. return ;
  547. } ;
  549. /*  get the buffersize that the default device uses for IO */
  550. count = sizeof (UInt32) ;
  551. if ((err = AudioDeviceGetProperty (audio_data.device, 0, false, kAudioDevicePropertyBufferSize,
  552. &count, &buffer_size)) != noErr)
  553. { printf ("AudioDeviceGetProperty (kAudioDevicePropertyBufferSize) failed.n") ;
  554. return ;
  555. } ;
  557. /*  get a description of the data format used by the default device */
  558. count = sizeof (AudioStreamBasicDescription) ;
  559. if ((err = AudioDeviceGetProperty (audio_data.device, 0, false, kAudioDevicePropertyStreamFormat,
  560. &count, &(audio_data.format))) != noErr)
  561. { printf ("AudioDeviceGetProperty (kAudioDevicePropertyStreamFormat) failed.n") ;
  562. return ;
  563. } ;
  565. /* Base setup completed. Now play files. */
  566. for (k = 1 ; k < argc ; k++)
  567. { printf ("Playing %sn", argv [k]) ;
  568. if (! (audio_data.sndfile = sf_open (argv [k], SFM_READ, &(audio_data.sfinfo))))
  569. { puts (sf_strerror (NULL)) ;
  570. continue ;
  571. } ;
  573. if (audio_data.sfinfo.channels < 1 || audio_data.sfinfo.channels > 2)
  574. { printf ("Error : channels = %d.n", audio_data.sfinfo.channels) ;
  575. continue ;
  576. } ;
  578. audio_data.format.mSampleRate = audio_data.sfinfo.samplerate ;
  580. if (audio_data.sfinfo.channels == 1)
  581. { audio_data.format.mChannelsPerFrame = 2 ;
  582. audio_data.fake_stereo = 1 ;
  583. }
  584. else
  585. audio_data.format.mChannelsPerFrame = audio_data.sfinfo.channels ;
  587. if ((err = AudioDeviceSetProperty (audio_data.device, NULL, 0, false, kAudioDevicePropertyStreamFormat,
  588. sizeof (AudioStreamBasicDescription), &(audio_data.format))) != noErr)
  589. { printf ("AudioDeviceSetProperty (kAudioDevicePropertyStreamFormat) failed.n") ;
  590. return ;
  591. } ;
  593. /*  we want linear pcm */
  594. if (audio_data.format.mFormatID != kAudioFormatLinearPCM)
  595. return ;
  597. /* Fire off the device. */
  598. if ((err = AudioDeviceAddIOProc (audio_data.device, macosx_audio_out_callback,
  599. (void *) &audio_data)) != noErr)
  600. { printf ("AudioDeviceAddIOProc failed.n") ;
  601. return ;
  602. } ;
  604. err = AudioDeviceStart (audio_data.device, macosx_audio_out_callback) ;
  605. if (err != noErr)
  606. return ;
  608. audio_data.done_playing = SF_FALSE ;
  610. while (audio_data.done_playing == SF_FALSE)
  611. usleep (10 * 1000) ; /* 10 000 milliseconds. */
  613. if ((err = AudioDeviceStop (audio_data.device, macosx_audio_out_callback)) != noErr)
  614. { printf ("AudioDeviceStop failed.n") ;
  615. return ;
  616. } ;
  618. err = AudioDeviceRemoveIOProc (audio_data.device, macosx_audio_out_callback) ;
  619. if (err != noErr)
  620. { printf ("AudioDeviceRemoveIOProc failed.n") ;
  621. return ;
  622. } ;
  624. sf_close (audio_data.sndfile) ;
  625. } ;
  627. return ;
  628. } /* macosx_play */
  630. #endif /* MacOSX */
  633. /*------------------------------------------------------------------------------
  634. ** Win32 functions for playing a sound.
  635. **
  636. ** This API sucks. Its needlessly complicated and is *WAY* too loose with
  637. ** passing pointers arounf in integers and and using char* pointers to
  638. **  point to data instead of short*. It plain sucks!
  639. */
  641. #if (OS_IS_WIN32 == 1)
  643. #define WIN32_BUFFER_LEN (1<<15)
  645. typedef struct
  646. { HWAVEOUT hwave ;
  647. WAVEHDR whdr [2] ;
  649. CRITICAL_SECTION mutex ; /* to control access to BuffersInUSe */
  650. HANDLE Event ; /* signal that a buffer is free */
  652. short buffer [WIN32_BUFFER_LEN / sizeof (short)] ;
  653. int current, bufferlen ;
  654. int BuffersInUse ;
  656. SNDFILE  *sndfile ;
  657. SF_INFO  sfinfo ;
  659. sf_count_t remaining ;
  660. } Win32_Audio_Data ;
  663. static void
  664. win32_play_data (Win32_Audio_Data *audio_data)
  665. { int thisread, readcount ;
  667. /* fill a buffer if there is more data and we can read it sucessfully */
  668. readcount = (audio_data->remaining > audio_data->bufferlen) ? audio_data->bufferlen : (int) audio_data->remaining ;
  670. thisread = (int) sf_read_short (audio_data->sndfile, (short *) (audio_data->whdr [audio_data->current].lpData), readcount) ;
  672. audio_data->remaining -= thisread ;
  674. if (thisread > 0)
  675. { /* Fix buffer length if this is only a partial block. */
  676. if (thisread < audio_data->bufferlen)
  677. audio_data->whdr [audio_data->current].dwBufferLength = thisread * sizeof (short) ;
  679. /* Queue the WAVEHDR */
  680. waveOutWrite (audio_data->hwave, (LPWAVEHDR) &(audio_data->whdr [audio_data->current]), sizeof (WAVEHDR)) ;
  682. /* count another buffer in use */
  683. EnterCriticalSection (&audio_data->mutex) ;
  684. audio_data->BuffersInUse ++ ;
  685. LeaveCriticalSection (&audio_data->mutex) ;
  687. /* use the other buffer next time */
  688. audio_data->current = (audio_data->current + 1) % 2 ;
  689. } ;
  691. return ;
  692. } /* win32_play_data */
  694. static void CALLBACK
  695. win32_audio_out_callback (HWAVEOUT hwave, UINT msg, DWORD_PTR data, DWORD param1, DWORD param2)
  696. { Win32_Audio_Data *audio_data ;
  698. /* Prevent compiler warnings. */
  699. hwave = hwave ;
  700. param1 = param2 ;
  702. if (data == 0)
  703. return ;
  705. /*
  706. ** I consider this technique of passing a pointer via an integer as
  707. ** fundamentally broken but thats the way microsoft has defined the
  708. ** interface.
  709. */
  710. audio_data = (Win32_Audio_Data*) data ;
  712. /* let main loop know a buffer is free */
  713. if (msg == MM_WOM_DONE)
  714. { EnterCriticalSection (&audio_data->mutex) ;
  715. audio_data->BuffersInUse -- ;
  716. LeaveCriticalSection (&audio_data->mutex) ;
  717. SetEvent (audio_data->Event) ;
  718. } ;
  720. return ;
  721. } /* win32_audio_out_callback */
  723. static void
  724. win32_play (int argc, char *argv [])
  725. { Win32_Audio_Data audio_data ;
  727. WAVEFORMATEX wf ;
  728. int k, error ;
  730. audio_data.sndfile = NULL ;
  731. audio_data.hwave = 0 ;
  733. for (k = 1 ; k < argc ; k++)
  734. { printf ("Playing %sn", argv [k]) ;
  736. if (! (audio_data.sndfile = sf_open (argv [k], SFM_READ, &(audio_data.sfinfo))))
  737. { puts (sf_strerror (NULL)) ;
  738. continue ;
  739. } ;
  741. audio_data.remaining = audio_data.sfinfo.frames * audio_data.sfinfo.channels ;
  742. audio_data.current = 0 ;
  744. InitializeCriticalSection (&audio_data.mutex) ;
  745. audio_data.Event = CreateEvent (0, FALSE, FALSE, 0) ;
  747. wf.nChannels = audio_data.sfinfo.channels ;
  748. wf.wFormatTag = WAVE_FORMAT_PCM ;
  749. wf.cbSize = 0 ;
  750. wf.wBitsPerSample = 16 ;
  752. wf.nSamplesPerSec = audio_data.sfinfo.samplerate ;
  754. wf.nBlockAlign = audio_data.sfinfo.channels * sizeof (short) ;
  756. wf.nAvgBytesPerSec = wf.nBlockAlign * wf.nSamplesPerSec ;
  758. error = waveOutOpen (&(audio_data.hwave), WAVE_MAPPER, &wf, (DWORD_PTR) win32_audio_out_callback,
  759. (DWORD_PTR) &audio_data, CALLBACK_FUNCTION) ;
  760. if (error)
  761. { puts ("waveOutOpen failed.") ;
  762. audio_data.hwave = 0 ;
  763. continue ;
  764. } ;
  766. audio_data.whdr [0].lpData = (char*) audio_data.buffer ;
  767. audio_data.whdr [1].lpData = ((char*) audio_data.buffer) + sizeof (audio_data.buffer) / 2 ;
  769. audio_data.whdr [0].dwBufferLength = sizeof (audio_data.buffer) / 2 ;
  770. audio_data.whdr [1].dwBufferLength = sizeof (audio_data.buffer) / 2 ;
  772. audio_data.whdr [0].dwFlags = 0 ;
  773. audio_data.whdr [1].dwFlags = 0 ;
  775. /* length of each audio buffer in samples */
  776. audio_data.bufferlen = sizeof (audio_data.buffer) / 2 / sizeof (short) ;
  778. /* Prepare the WAVEHDRs */
  779. if ((error = waveOutPrepareHeader (audio_data.hwave, &(audio_data.whdr [0]), sizeof (WAVEHDR))))
  780. { printf ("waveOutPrepareHeader [0] failed : %08Xn", error) ;
  781. waveOutClose (audio_data.hwave) ;
  782. continue ;
  783. } ;
  785. if ((error = waveOutPrepareHeader (audio_data.hwave, &(audio_data.whdr [1]), sizeof (WAVEHDR))))
  786. { printf ("waveOutPrepareHeader [1] failed : %08Xn", error) ;
  787. waveOutUnprepareHeader (audio_data.hwave, &(audio_data.whdr [0]), sizeof (WAVEHDR)) ;
  788. waveOutClose (audio_data.hwave) ;
  789. continue ;
  790. } ;
  792. /* Fill up both buffers with audio data */
  793. audio_data.BuffersInUse = 0 ;
  794. win32_play_data (&audio_data) ;
  795. win32_play_data (&audio_data) ;
  797. /* loop until both buffers are released */
  798. while (audio_data.BuffersInUse > 0)
  799. {
  800. /* wait for buffer to be released */
  801. WaitForSingleObject (audio_data.Event, INFINITE) ;
  803. /* refill the buffer if there is more data to play */
  804. win32_play_data (&audio_data) ;
  805. } ;
  807. waveOutUnprepareHeader (audio_data.hwave, &(audio_data.whdr [0]), sizeof (WAVEHDR)) ;
  808. waveOutUnprepareHeader (audio_data.hwave, &(audio_data.whdr [1]), sizeof (WAVEHDR)) ;
  810. waveOutClose (audio_data.hwave) ;
  811. audio_data.hwave = 0 ;
  813. DeleteCriticalSection (&audio_data.mutex) ;
  815. sf_close (audio_data.sndfile) ;
  816. } ;
  818. } /* win32_play */
  820. #endif /* Win32 */
  822. /*------------------------------------------------------------------------------
  823. ** Solaris.
  824. */
  826. #if (defined (sun) && defined (unix)) /* ie Solaris */
  828. static void
  829. solaris_play (int argc, char *argv [])
  830. { static short  buffer [BUFFER_LEN] ;
  831. audio_info_t audio_info ;
  832. SNDFILE *sndfile ;
  833. SF_INFO sfinfo ;
  834. unsigned long delay_time ;
  835. long k, start_count, output_count, write_count, read_count ;
  836. int audio_fd, error, done ;
  838. for (k = 1 ; k < argc ; k++)
  839. { printf ("Playing %sn", argv [k]) ;
  840. if (! (sndfile = sf_open (argv [k], SFM_READ, &sfinfo)))
  841. { puts (sf_strerror (NULL)) ;
  842. continue ;
  843. } ;
  845. if (sfinfo.channels < 1 || sfinfo.channels > 2)
  846. { printf ("Error : channels = %d.n", sfinfo.channels) ;
  847. continue ;
  848. } ;
  850. /* open the audio device - write only, non-blocking */
  851. if ((audio_fd = open ("/dev/audio", O_WRONLY | O_NONBLOCK)) < 0)
  852. { perror ("open (/dev/audio) failed") ;
  853. return ;
  854. } ;
  856. /* Retrive standard values. */
  857. AUDIO_INITINFO (&audio_info) ;
  859. audio_info.play.sample_rate = sfinfo.samplerate ;
  860. audio_info.play.channels = sfinfo.channels ;
  861. audio_info.play.precision = 16 ;
  862. audio_info.play.encoding = AUDIO_ENCODING_LINEAR ;
  863. audio_info.play.gain = AUDIO_MAX_GAIN ;
  864. audio_info.play.balance = AUDIO_MID_BALANCE ;
  866. if ((error = ioctl (audio_fd, AUDIO_SETINFO, &audio_info)))
  867. { perror ("ioctl (AUDIO_SETINFO) failed") ;
  868. return ;
  869. } ;
  871. /* Delay time equal to 1/4 of a buffer in microseconds. */
  872. delay_time = (BUFFER_LEN * 1000000) / (audio_info.play.sample_rate * 4) ;
  874. done = 0 ;
  875. while (! done)
  876. { read_count = sf_read_short (sndfile, buffer, BUFFER_LEN) ;
  877. if (read_count < BUFFER_LEN)
  878. { memset (&(buffer [read_count]), 0, (BUFFER_LEN - read_count) * sizeof (short)) ;
  879. /* Tell the main application to terminate. */
  880. done = SF_TRUE ;
  881. } ;
  883. start_count = 0 ;
  884. output_count = BUFFER_LEN * sizeof (short) ;
  886. while (output_count > 0)
  887. { /* write as much data as possible */
  888. write_count = write (audio_fd, &(buffer [start_count]), output_count) ;
  889. if (write_count > 0)
  890. { output_count -= write_count ;
  891. start_count += write_count ;
  892. }
  893. else
  894. { /* Give the audio output time to catch up. */
  895. usleep (delay_time) ;
  896. } ;
  897. } ; /* while (outpur_count > 0) */
  898. } ; /* while (! done) */
  900. close (audio_fd) ;
  901. } ;
  903. return ;
  904. } /* solaris_play */
  906. #endif /* Solaris */
  908. /*==============================================================================
  909. ** Main function.
  910. */
  912. int
  913. main (int argc, char *argv [])
  914. {
  915. if (argc < 2)
  916. {
  917. printf ("nUsage : %s <input sound file>nn", argv [0]) ;
  918. #if (OS_IS_WIN32 == 1)
  919. printf ("This is a Unix style command line application whichn"
  920. "should be run in a MSDOS box or Command Shell window.nn") ;
  921. printf ("Sleeping for 5 seconds before exiting.nn") ;
  923. /* This is the officially blessed by microsoft way but I can't get
  924. ** it to link.
  925. **     Sleep (15) ;
  926. ** Instead, use this:
  927. */
  928. Sleep (5 * 1000) ;
  929. #endif
  930. return 1 ;
  931. } ;
  933. #if defined (__linux__)
  934. #if HAVE_ALSA_ASOUNDLIB_H
  935. if (access ("/proc/asound/cards", R_OK) == 0)
  936. alsa_play (argc, argv) ;
  937. else
  938. #endif
  939. opensoundsys_play (argc, argv) ;
  940. #elif defined (__FreeBSD_kernel__) || defined (__FreeBSD__)
  941. opensoundsys_play (argc, argv) ;
  942. #elif (defined (__MACH__) && defined (__APPLE__))
  943. macosx_play (argc, argv) ;
  944. #elif (defined (sun) && defined (unix))
  945. solaris_play (argc, argv) ;
  946. #elif (OS_IS_WIN32 == 1)
  947. win32_play (argc, argv) ;
  948. #elif defined (__BEOS__)
  949. printf ("This program cannot be compiled on BeOS.n") ;
  950. printf ("Instead, compile the file sfplay_beos.cpp.n") ;
  951. return 1 ;
  952. #else
  953. puts ("*** Playing sound not yet supported on this platform.") ;
  954. puts ("*** Please feel free to submit a patch.") ;
  955. return 1 ;
  956. #endif
  958. return 0 ;
  959. } /* main */