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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
SDL_dx5audio.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：19k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

SDL_dx5audio.c：源码内容
  1. /*
  2.     SDL - Simple DirectMedia Layer
  3.     Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002  Sam Lantinga
  5.     This library is free software; you can redistribute it and/or
  6.     modify it under the terms of the GNU Library General Public
  7.     License as published by the Free Software Foundation; either
  8.     version 2 of the License, or (at your option) any later version.
  10.     This library 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 GNU
  13.     Library General Public License for more details.
  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
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.     Sam Lantinga
  20.     slouken@libsdl.org
  21. */
  23. #ifdef SAVE_RCSID
  24. static char rcsid =
  25.  "@(#) $Id: SDL_dx5audio.c,v 1.6 2002/04/22 21:38:02 wmay Exp $";
  26. #endif
  28. /* Allow access to a raw mixing buffer */
  30. #include <stdio.h>
  32. #include "SDL_types.h"
  33. #include "SDL_error.h"
  34. #include "SDL_timer.h"
  35. #include "SDL_audio.h"
  36. #include "SDL_audio_c.h"
  37. #include "SDL_dx5audio.h"
  39. /* Define this if you want to use DirectX 6 DirectSoundNotify interface */
  40. //#define USE_POSITION_NOTIFY
  42. /* DirectX function pointers for audio */
  43. HRESULT (WINAPI *DSoundCreate)(LPGUID, LPDIRECTSOUND *, LPUNKNOWN);
  45. /* Audio driver functions */
  46. static int DX5_OpenAudio(_THIS, SDL_AudioSpec *spec);
  47. static void DX5_ThreadInit(_THIS);
  48. static void DX5_WaitAudio_BusyWait(_THIS);
  49. #ifdef USE_POSITION_NOTIFY
  50. static void DX6_WaitAudio_EventWait(_THIS);
  51. #endif
  52. static void DX5_PlayAudio(_THIS);
  53. static Uint8 *DX5_GetAudioBuf(_THIS);
  54. static void DX5_WaitDone(_THIS);
  55. static void DX5_CloseAudio(_THIS);
  56. static int DX5_AudioDelayMsec(_THIS);
  58. /* Audio driver bootstrap functions */
  60. static int Audio_Available(void)
  61. {
  62. HINSTANCE DSoundDLL;
  63. int dsound_ok;
  65. /* Version check DSOUND.DLL (Is DirectX okay?) */
  66. dsound_ok = 0;
  67. DSoundDLL = LoadLibrary("DSOUND.DLL");
  68. if ( DSoundDLL != NULL ) {
  69. /* We just use basic DirectSound, we're okay */
  70. /* Yay! */
  71. /* Unfortunately, the sound drivers on NT have
  72.    higher latencies than the audio buffers used
  73.    by many SDL applications, so there are gaps
  74.    in the audio - it sounds terrible.  Punt for now.
  75.  */
  76. OSVERSIONINFO ver;
  77. ver.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
  78. GetVersionEx(&ver);
  79. switch (ver.dwPlatformId) {
  80. case VER_PLATFORM_WIN32_NT:
  81. if ( ver.dwMajorVersion > 4 ) {
  82. /* Win2K */
  83. dsound_ok = 1;
  84. } else {
  85. /* WinNT */
  86. dsound_ok = 0;
  87. }
  88. break;
  89. default:
  90. /* Win95 or Win98 */
  91. dsound_ok = 1;
  92. break;
  93. }
  94. /* Now check for DirectX 5 or better - otherwise
  95.  * we will fail later in DX5_OpenAudio without a chance
  96.  * to fall back to the DIB driver. */
  97. if (dsound_ok) {
  98. /* DirectSoundCaptureCreate was added in DX5 */
  99. if (!GetProcAddress(DSoundDLL, "DirectSoundCaptureCreate"))
  100. dsound_ok = 0;
  102. }
  103. /* Clean up.. */
  104. FreeLibrary(DSoundDLL);
  105. }
  106. return(dsound_ok);
  107. }
  109. /* Functions for loading the DirectX functions dynamically */
  110. static HINSTANCE DSoundDLL = NULL;
  112. static void DX5_Unload(void)
  113. {
  114. if ( DSoundDLL != NULL ) {
  115. FreeLibrary(DSoundDLL);
  116. DSoundCreate = NULL;
  117. DSoundDLL = NULL;
  118. }
  119. }
  120. static int DX5_Load(void)
  121. {
  122. int status;
  124. DX5_Unload();
  125. DSoundDLL = LoadLibrary("DSOUND.DLL");
  126. if ( DSoundDLL != NULL ) {
  127. DSoundCreate = (void *)GetProcAddress(DSoundDLL,
  128. "DirectSoundCreate");
  129. }
  130. if ( DSoundDLL && DSoundCreate ) {
  131. status = 0;
  132. } else {
  133. DX5_Unload();
  134. status = -1;
  135. }
  136. return status;
  137. }
  139. static void Audio_DeleteDevice(SDL_AudioDevice *device)
  140. {
  141. DX5_Unload();
  142. free(device->hidden);
  143. free(device);
  144. }
  146. static SDL_AudioDevice *Audio_CreateDevice(int devindex)
  147. {
  148. SDL_AudioDevice *this;
  150. /* Load DirectX */
  151. if ( DX5_Load() < 0 ) {
  152. return(NULL);
  153. }
  155. /* Initialize all variables that we clean on shutdown */
  156. this = (SDL_AudioDevice *)malloc(sizeof(SDL_AudioDevice));
  157. if ( this ) {
  158. memset(this, 0, (sizeof *this));
  159. this->hidden = (struct SDL_PrivateAudioData *)
  160. malloc((sizeof *this->hidden));
  161. }
  162. if ( (this == NULL) || (this->hidden == NULL) ) {
  163. SDL_OutOfMemory();
  164. if ( this ) {
  165. free(this);
  166. }
  167. return(0);
  168. }
  169. memset(this->hidden, 0, (sizeof *this->hidden));
  171. /* Set the function pointers */
  172. this->OpenAudio = DX5_OpenAudio;
  173. this->ThreadInit = DX5_ThreadInit;
  174. this->WaitAudio = DX5_WaitAudio_BusyWait;
  175. this->PlayAudio = DX5_PlayAudio;
  176. this->GetAudioBuf = DX5_GetAudioBuf;
  177. this->WaitDone = DX5_WaitDone;
  178. this->CloseAudio = DX5_CloseAudio;
  179. this->AudioDelayMsec = DX5_AudioDelayMsec;
  181. this->free = Audio_DeleteDevice;
  183. return this;
  184. }
  186. AudioBootStrap DSOUND_bootstrap = {
  187. "dsound", "Win95/98/2000 DirectSound",
  188. Audio_Available, Audio_CreateDevice
  189. };
  191. static void SetDSerror(const char *function, int code)
  192. {
  193. static const char *error;
  194. static char  errbuf[BUFSIZ];
  196. errbuf[0] = 0;
  197. switch (code) {
  198. case E_NOINTERFACE:
  199. error = 
  200. "Unsupported interfacen-- Is DirectX 5.0 or later installed?";
  201. break;
  202. case DSERR_ALLOCATED:
  203. error = "Audio device in use";
  204. break;
  205. case DSERR_BADFORMAT:
  206. error = "Unsupported audio format";
  207. break;
  208. case DSERR_BUFFERLOST:
  209. error = "Mixing buffer was lost";
  210. break;
  211. case DSERR_CONTROLUNAVAIL:
  212. error = "Control requested is not available";
  213. break;
  214. case DSERR_INVALIDCALL:
  215. error = "Invalid call for the current state";
  216. break;
  217. case DSERR_INVALIDPARAM:
  218. error = "Invalid parameter";
  219. break;
  220. case DSERR_NODRIVER:
  221. error = "No audio device found";
  222. break;
  223. case DSERR_OUTOFMEMORY:
  224. error = "Out of memory";
  225. break;
  226. case DSERR_PRIOLEVELNEEDED:
  227. error = "Caller doesn't have priority";
  228. break;
  229. case DSERR_UNSUPPORTED:
  230. error = "Function not supported";
  231. break;
  232. default:
  233. sprintf(errbuf, "%s: Unknown DirectSound error: 0x%x",
  234. function, code);
  235. break;
  236. }
  237. if ( ! errbuf[0] ) {
  238. sprintf(errbuf, "%s: %s", function, error);
  239. }
  240. SDL_SetError("%s", errbuf);
  241. return;
  242. }
  244. /* DirectSound needs to be associated with a window */
  245. static HWND mainwin = NULL;
  246. /* */
  247. void DX5_SoundFocus(HWND hwnd)
  248. {
  249. mainwin = hwnd;
  250. }
  252. static void DX5_ThreadInit(_THIS)
  253. {
  254. SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
  255. }
  257. static void DX5_WaitAudio_BusyWait(_THIS)
  258. {
  259. DWORD status;
  260. DWORD cursor, junk;
  261. HRESULT result;
  263. /* Semi-busy wait, since we have no way of getting play notification
  264.    on a primary mixing buffer located in hardware (DirectX 5.0)
  265. */
  266. result = IDirectSoundBuffer_GetCurrentPosition(mixbuf, &cursor, &junk);
  267. if ( result != DS_OK ) {
  268. if ( result == DSERR_BUFFERLOST ) {
  269. IDirectSoundBuffer_Restore(mixbuf);
  270. }
  271. #ifdef DEBUG_SOUND
  272. SetDSerror("DirectSound GetCurrentPosition", result);
  273. #endif
  274. return;
  275. }
  276. cursor /= mixlen;
  278. while ( cursor == playing ) {
  279. /* FIXME: find out how much time is left and sleep that long */
  280. SDL_Delay(10);
  282. /* Try to restore a lost sound buffer */
  283. IDirectSoundBuffer_GetStatus(mixbuf, &status);
  284. if ( (status&DSBSTATUS_BUFFERLOST) ) {
  285. IDirectSoundBuffer_Restore(mixbuf);
  286. IDirectSoundBuffer_GetStatus(mixbuf, &status);
  287. if ( (status&DSBSTATUS_BUFFERLOST) ) {
  288. break;
  289. }
  290. }
  291. if ( ! (status&DSBSTATUS_PLAYING) ) {
  292. result = IDirectSoundBuffer_Play(mixbuf, 0, 0, DSBPLAY_LOOPING);
  293. if ( result == DS_OK ) {
  294. continue;
  295. }
  296. #ifdef DEBUG_SOUND
  297. SetDSerror("DirectSound Play", result);
  298. #endif
  299. return;
  300. }
  302. /* Find out where we are playing */
  303. result = IDirectSoundBuffer_GetCurrentPosition(mixbuf,
  304. &cursor, &junk);
  305. if ( result != DS_OK ) {
  306. SetDSerror("DirectSound GetCurrentPosition", result);
  307. return;
  308. }
  309. cursor /= mixlen;
  310. }
  311. }
  313. #ifdef USE_POSITION_NOTIFY
  314. static void DX6_WaitAudio_EventWait(_THIS)
  315. {
  316. DWORD status;
  317. HRESULT result;
  319. /* Try to restore a lost sound buffer */
  320. IDirectSoundBuffer_GetStatus(mixbuf, &status);
  321. if ( (status&DSBSTATUS_BUFFERLOST) ) {
  322. IDirectSoundBuffer_Restore(mixbuf);
  323. IDirectSoundBuffer_GetStatus(mixbuf, &status);
  324. if ( (status&DSBSTATUS_BUFFERLOST) ) {
  325. return;
  326. }
  327. }
  328. if ( ! (status&DSBSTATUS_PLAYING) ) {
  329. result = IDirectSoundBuffer_Play(mixbuf, 0, 0, DSBPLAY_LOOPING);
  330. if ( result != DS_OK ) {
  331. #ifdef DEBUG_SOUND
  332. SetDSerror("DirectSound Play", result);
  333. #endif
  334. return;
  335. }
  336. }
  337. WaitForSingleObject(audio_event, INFINITE);
  338. }
  339. #endif /* USE_POSITION_NOTIFY */
  341. static void DX5_PlayAudio(_THIS)
  342. {
  343. /* Unlock the buffer, allowing it to play */
  344. if ( locked_buf ) {
  345. IDirectSoundBuffer_Unlock(mixbuf, locked_buf, mixlen, NULL, 0);
  346. }
  348. }
  350. static Uint8 *DX5_GetAudioBuf(_THIS)
  351. {
  352. DWORD   cursor, junk;
  353. HRESULT result;
  354. DWORD   rawlen;
  356. /* Figure out which blocks to fill next */
  357. locked_buf = NULL;
  358. result = IDirectSoundBuffer_GetCurrentPosition(mixbuf, &cursor, &junk);
  359. if ( result == DSERR_BUFFERLOST ) {
  360. IDirectSoundBuffer_Restore(mixbuf);
  361. result = IDirectSoundBuffer_GetCurrentPosition(mixbuf,
  362. &cursor, &junk);
  363. }
  364. if ( result != DS_OK ) {
  365. SetDSerror("DirectSound GetCurrentPosition", result);
  366. return(NULL);
  367. }
  368. cursor /= mixlen;
  369. playing = cursor;
  370. cursor = (cursor+1)%NUM_BUFFERS;
  371. cursor *= mixlen;
  373. /* Lock the audio buffer */
  374. result = IDirectSoundBuffer_Lock(mixbuf, cursor, mixlen,
  375. (LPVOID *)&locked_buf, &rawlen, NULL, &junk, 0);
  376. if ( result == DSERR_BUFFERLOST ) {
  377. IDirectSoundBuffer_Restore(mixbuf);
  378. result = IDirectSoundBuffer_Lock(mixbuf, cursor, mixlen,
  379. (LPVOID *)&locked_buf, &rawlen, NULL, &junk, 0);
  380. }
  381. if ( result != DS_OK ) {
  382. SetDSerror("DirectSound Lock", result);
  383. return(NULL);
  384. }
  385. return(locked_buf);
  386. }
  388. static void DX5_WaitDone(_THIS)
  389. {
  390. Uint8 *stream;
  392. /* Wait for the playing chunk to finish */
  393. stream = this->GetAudioBuf(this);
  394. if ( stream != NULL ) {
  395. memset(stream, silence, mixlen);
  396. this->PlayAudio(this);
  397. }
  398. this->WaitAudio(this);
  400. /* Stop the looping sound buffer */
  401. IDirectSoundBuffer_Stop(mixbuf);
  402. }
  404. static void DX5_CloseAudio(_THIS)
  405. {
  406. if ( sound != NULL ) {
  407. if ( mixbuf != NULL ) {
  408. /* Clean up the audio buffer */
  409. IDirectSoundBuffer_Release(mixbuf);
  410. mixbuf = NULL;
  411. }
  412. if ( audio_event != NULL ) {
  413. CloseHandle(audio_event);
  414. audio_event = NULL;
  415. }
  416. IDirectSound_Release(sound);
  417. sound = NULL;
  418. }
  419. }
  421. /* This function tries to create a primary audio buffer, and returns the
  422.    number of audio chunks available in the created buffer.
  423. */
  424. static int CreatePrimary(LPDIRECTSOUND sndObj, HWND focus, 
  425. LPDIRECTSOUNDBUFFER *sndbuf, WAVEFORMATEX *wavefmt, Uint32 chunksize)
  426. {
  427. HRESULT result;
  428. DSBUFFERDESC format;
  429. DSBCAPS caps;
  430. int numchunks;
  432. /* Try to set primary mixing privileges */
  433. result = IDirectSound_SetCooperativeLevel(sndObj, focus,
  434. DSSCL_WRITEPRIMARY);
  435. if ( result != DS_OK ) {
  436. #ifdef DEBUG_SOUND
  437. SetDSerror("DirectSound SetCooperativeLevel", result);
  438. #endif
  439. return(-1);
  440. }
  442. /* Try to create the primary buffer */
  443. memset(&format, 0, sizeof(format));
  444. format.dwSize = sizeof(format);
  445. format.dwFlags=(DSBCAPS_PRIMARYBUFFER|DSBCAPS_GETCURRENTPOSITION2);
  446. format.dwFlags |= DSBCAPS_STICKYFOCUS;
  447. #ifdef USE_POSITION_NOTIFY
  448. format.dwFlags |= DSBCAPS_CTRLPOSITIONNOTIFY;
  449. #endif
  450. result = IDirectSound_CreateSoundBuffer(sndObj, &format, sndbuf, NULL);
  451. if ( result != DS_OK ) {
  452. #ifdef DEBUG_SOUND
  453. SetDSerror("DirectSound CreateSoundBuffer", result);
  454. #endif
  455. return(-1);
  456. }
  458. /* Check the size of the fragment buffer */
  459. memset(&caps, 0, sizeof(caps));
  460. caps.dwSize = sizeof(caps);
  461. result = IDirectSoundBuffer_GetCaps(*sndbuf, &caps);
  462. if ( result != DS_OK ) {
  463. #ifdef DEBUG_SOUND
  464. SetDSerror("DirectSound GetCaps", result);
  465. #endif
  466. IDirectSoundBuffer_Release(*sndbuf);
  467. return(-1);
  468. }
  469. if ( (chunksize > caps.dwBufferBytes) ||
  470. ((caps.dwBufferBytes%chunksize) != 0) ) {
  471. /* The primary buffer size is not a multiple of 'chunksize'
  472.    -- this hopefully doesn't happen when 'chunksize' is a 
  473.       power of 2.
  474. */
  475. IDirectSoundBuffer_Release(*sndbuf);
  476. SDL_SetError(
  477. "Primary buffer size is: %d, cannot break it into chunks of %d bytesn",
  478. caps.dwBufferBytes, chunksize);
  479. return(-1);
  480. }
  481. numchunks = (caps.dwBufferBytes/chunksize);
  483. /* Set the primary audio format */
  484. result = IDirectSoundBuffer_SetFormat(*sndbuf, wavefmt);
  485. if ( result != DS_OK ) {
  486. #ifdef DEBUG_SOUND
  487. SetDSerror("DirectSound SetFormat", result);
  488. #endif
  489. IDirectSoundBuffer_Release(*sndbuf);
  490. return(-1);
  491. }
  492. return(numchunks);
  493. }
  495. /* This function tries to create a secondary audio buffer, and returns the
  496.    number of audio chunks available in the created buffer.
  497. */
  498. static int CreateSecondary(LPDIRECTSOUND sndObj, HWND focus,
  499. LPDIRECTSOUNDBUFFER *sndbuf, WAVEFORMATEX *wavefmt, Uint32 chunksize)
  500. {
  501. const int numchunks = 2;
  502. HRESULT result;
  503. DSBUFFERDESC format;
  504. LPVOID pvAudioPtr1, pvAudioPtr2;
  505. DWORD  dwAudioBytes1, dwAudioBytes2;
  507. /* Try to set primary mixing privileges */
  508. if ( focus ) {
  509. result = IDirectSound_SetCooperativeLevel(sndObj,
  510. focus, DSSCL_PRIORITY);
  511. } else {
  512. result = IDirectSound_SetCooperativeLevel(sndObj,
  513. GetDesktopWindow(), DSSCL_NORMAL);
  514. }
  515. if ( result != DS_OK ) {
  516. #ifdef DEBUG_SOUND
  517. SetDSerror("DirectSound SetCooperativeLevel", result);
  518. #endif
  519. return(-1);
  520. }
  522. /* Try to create the secondary buffer */
  523. memset(&format, 0, sizeof(format));
  524. format.dwSize = sizeof(format);
  525. format.dwFlags = DSBCAPS_GETCURRENTPOSITION2;
  526. #ifdef USE_POSITION_NOTIFY
  527. format.dwFlags |= DSBCAPS_CTRLPOSITIONNOTIFY;
  528. #endif
  529. if ( ! focus ) {
  530. format.dwFlags |= DSBCAPS_GLOBALFOCUS;
  531. } else {
  532. format.dwFlags |= DSBCAPS_STICKYFOCUS;
  533. }
  534. format.dwBufferBytes = numchunks*chunksize;
  535. if ( (format.dwBufferBytes < DSBSIZE_MIN) ||
  536.      (format.dwBufferBytes > DSBSIZE_MAX) ) {
  537. SDL_SetError("Sound buffer size must be between %d and %d",
  538. DSBSIZE_MIN/numchunks, DSBSIZE_MAX/numchunks);
  539. return(-1);
  540. }
  541. format.dwReserved = 0;
  542. format.lpwfxFormat = wavefmt;
  543. result = IDirectSound_CreateSoundBuffer(sndObj, &format, sndbuf, NULL);
  544. if ( result != DS_OK ) {
  545. SetDSerror("DirectSound CreateSoundBuffer", result);
  546. return(-1);
  547. }
  548. IDirectSoundBuffer_SetFormat(*sndbuf, wavefmt);
  550. /* Silence the initial audio buffer */
  551. result = IDirectSoundBuffer_Lock(*sndbuf, 0, format.dwBufferBytes,
  552.                                  (LPVOID *)&pvAudioPtr1, &dwAudioBytes1,
  553.                                  (LPVOID *)&pvAudioPtr2, &dwAudioBytes2,
  554.                                  DSBLOCK_ENTIREBUFFER);
  555. if ( result == DS_OK ) {
  556. if ( wavefmt->wBitsPerSample == 8 ) {
  557. memset(pvAudioPtr1, 0x80, dwAudioBytes1);
  558. } else {
  559. memset(pvAudioPtr1, 0x00, dwAudioBytes1);
  560. }
  561. IDirectSoundBuffer_Unlock(*sndbuf,
  562.                           (LPVOID)pvAudioPtr1, dwAudioBytes1,
  563.                           (LPVOID)pvAudioPtr2, dwAudioBytes2);
  564. }
  566. /* We're ready to go */
  567. return(numchunks);
  568. }
  570. /* This function tries to set position notify events on the mixing buffer */
  571. #ifdef USE_POSITION_NOTIFY
  572. static int CreateAudioEvent(_THIS)
  573. {
  574. LPDIRECTSOUNDNOTIFY notify;
  575. DSBPOSITIONNOTIFY *notify_positions;
  576. int i, retval;
  577. HRESULT result;
  579. /* Default to fail on exit */
  580. retval = -1;
  581. notify = NULL;
  583. /* Query for the interface */
  584. result = IDirectSoundBuffer_QueryInterface(mixbuf,
  585. &IID_IDirectSoundNotify, (void *)&notify);
  586. if ( result != DS_OK ) {
  587. goto done;
  588. }
  590. /* Allocate the notify structures */
  591. notify_positions = (DSBPOSITIONNOTIFY *)malloc(NUM_BUFFERS*
  592. sizeof(*notify_positions));
  593. if ( notify_positions == NULL ) {
  594. goto done;
  595. }
  597. /* Create the notify event */
  598. audio_event = CreateEvent(NULL, FALSE, FALSE, NULL);
  599. if ( audio_event == NULL ) {
  600. goto done;
  601. }
  603. /* Set up the notify structures */
  604. for ( i=0; i<NUM_BUFFERS; ++i ) {
  605. notify_positions[i].dwOffset = i*mixlen;
  606. notify_positions[i].hEventNotify = audio_event;
  607. }
  608. result = IDirectSoundNotify_SetNotificationPositions(notify,
  609. NUM_BUFFERS, notify_positions);
  610. if ( result == DS_OK ) {
  611. retval = 0;
  612. }
  613. done:
  614. if ( notify != NULL ) {
  615. IDirectSoundNotify_Release(notify);
  616. }
  617. return(retval);
  618. }
  619. #endif /* USE_POSITION_NOTIFY */
  621. static int DX5_OpenAudio(_THIS, SDL_AudioSpec *spec)
  622. {
  623. HRESULT      result;
  624. WAVEFORMATEX waveformat;
  626. /* Set basic WAVE format parameters */
  627. memset(&waveformat, 0, sizeof(waveformat));
  628. waveformat.wFormatTag = WAVE_FORMAT_PCM;
  630. /* Determine the audio parameters from the AudioSpec */
  631. switch ( spec->format & 0xFF ) {
  632. case 8:
  633. /* Unsigned 8 bit audio data */
  634. spec->format = AUDIO_U8;
  635. silence = 0x80;
  636. waveformat.wBitsPerSample = 8;
  637. break;
  638. case 16:
  639. /* Signed 16 bit audio data */
  640. spec->format = AUDIO_S16;
  641. silence = 0x00;
  642. waveformat.wBitsPerSample = 16;
  643. break;
  644. default:
  645. SDL_SetError("Unsupported audio format");
  646. return(-1);
  647. }
  648. waveformat.nChannels = spec->channels;
  649. waveformat.nSamplesPerSec = spec->freq;
  650. waveformat.nBlockAlign =
  651. waveformat.nChannels * (waveformat.wBitsPerSample/8);
  652. waveformat.nAvgBytesPerSec = 
  653. waveformat.nSamplesPerSec * waveformat.nBlockAlign;
  655. /* Update the fragment size as size in bytes */
  656. SDL_CalculateAudioSpec(spec);
  658. /* Open the audio device */
  659. result = DSoundCreate(NULL, &sound, NULL);
  660. if ( result != DS_OK ) {
  661. SetDSerror("DirectSoundCreate", result);
  662. return(-1);
  663. }
  665. /* Create the audio buffer to which we write */
  666. NUM_BUFFERS = -1;
  667. if ( mainwin ) {
  668. NUM_BUFFERS = CreatePrimary(sound, mainwin, &mixbuf,
  669. &waveformat, spec->size);
  670. }
  671. if ( NUM_BUFFERS < 0 ) {
  672. NUM_BUFFERS = CreateSecondary(sound, mainwin, &mixbuf,
  673. &waveformat, spec->size);
  674. if ( NUM_BUFFERS < 0 ) {
  675. return(-1);
  676. }
  677. #ifdef DEBUG_SOUND
  678. fprintf(stderr, "Using secondary audio buffern");
  679. #endif
  680. }
  681. #ifdef DEBUG_SOUND
  682. else
  683. fprintf(stderr, "Using primary audio buffern");
  684. #endif
  686. /* The buffer will auto-start playing in DX5_WaitAudio() */
  687. playing = 0;
  688. mixlen = spec->size;
  690. #ifdef USE_POSITION_NOTIFY
  691. /* See if we can use DirectX 6 event notification */
  692. if ( CreateAudioEvent(this) == 0 ) {
  693. this->WaitAudio = DX6_WaitAudio_EventWait;
  694. } else {
  695. this->WaitAudio = DX5_WaitAudio_BusyWait;
  696. }
  697. #endif
  698. return(0);
  699. }
  701. static int DX5_AudioDelayMsec (_THIS)
  702. {
  703.       DWORD cursor, write;
  704.       HRESULT result;
  705.       int odelay;
  706.       /* char buffer[80]; */
  708.       result = IDirectSoundBuffer_GetCurrentPosition(mixbuf, &cursor, &write);+       write = cursor / mixlen;
  709.       write = (write+1)%NUM_BUFFERS;
  710.       write *= mixlen;
  712.       if (result == DS_OK) {
  713.       /* 
  714.        * delay in msec is bytes  * 1000 / (bytes per sample * channels * freq)+        */
  715.               odelay = (write - cursor);
  716.               odelay *= 1000;
  717.               odelay /= this->spec.channels;
  718.               if (!(this->spec.format == AUDIO_U8 ||  
  719.                       this->spec.format == AUDIO_S8)) {
  720.                       odelay /= 2; // 2 bytes per sample
  721.               }
  722.               odelay /= this->spec.freq;
  723.               return odelay;
  724.       } 
  725.       return -1;
  726. }