This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_dart.c
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
20
21
Sam Lantinga
slouken@libsdl.org
*/
22
#include "SDL_config.h"
23
24
25
26
27
/* Allow access to a raw mixing buffer */
#include "SDL_timer.h"
#include "SDL_audio.h"
28
#include "../SDL_audio_c.h"
29
30
31
32
33
34
#include "SDL_dart.h"
// Buffer states:
#define BUFFER_EMPTY 0
#define BUFFER_USED 1
35
36
37
38
typedef struct _tMixBufferDesc
{
int iBufferUsage; // BUFFER_EMPTY or BUFFER_USED
SDL_AudioDevice *pSDLAudioDevice;
39
40
41
42
43
44
} tMixBufferDesc, *pMixBufferDesc;
//---------------------------------------------------------------------
// DARTEventFunc
//
45
// This function is called by DART, when an event occurs, like end of
46
47
// playback of a buffer, etc...
//---------------------------------------------------------------------
48
static LONG APIENTRY
49
DARTEventFunc(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer, ULONG ulFlags)
50
{
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
if (ulFlags && MIX_WRITE_COMPLETE) { // Playback of buffer completed!
// Get pointer to buffer description
pMixBufferDesc pBufDesc;
if (pBuffer) {
pBufDesc = (pMixBufferDesc) (*pBuffer).ulUserParm;
if (pBufDesc) {
SDL_AudioDevice *pSDLAudioDevice = pBufDesc->pSDLAudioDevice;
// Set the buffer to be empty
pBufDesc->iBufferUsage = BUFFER_EMPTY;
// And notify DART feeder thread that it will have to work a bit.
if (pSDLAudioDevice)
DosPostEventSem(pSDLAudioDevice->hidden->
hevAudioBufferPlayed);
}
}
69
}
71
72
73
}
74
75
static int
DART_OpenDevice(_THIS, const char *devname, int iscapture)
76
{
77
SDL_AudioFormat test_format = SDL_FirstAudioFormat(_this->spec.format);
78
int valid_datatype = 0;
79
80
81
82
83
84
85
86
87
88
89
90
MCI_AMP_OPEN_PARMS AmpOpenParms;
int iDeviceOrd = 0; // Default device to be used
int bOpenShared = 1; // Try opening it shared
int iBits = 16; // Default is 16 bits signed
int iFreq = 44100; // Default is 44KHz
int iChannels = 2; // Default is 2 channels (Stereo)
int iNumBufs = 2; // Number of audio buffers: 2
int iBufSize;
int iOpenMode;
int iSilence;
int rc;
91
92
/* Initialize all variables that we clean on shutdown */
_this->hidden = (struct SDL_PrivateAudioData *)
93
SDL_malloc((sizeof *_this->hidden));
94
95
96
97
98
99
if (_this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(_this->hidden, 0, (sizeof *_this->hidden));
100
101
102
103
104
105
106
107
108
109
110
// First thing is to try to open a given DART device!
SDL_memset(&AmpOpenParms, 0, sizeof(MCI_AMP_OPEN_PARMS));
// pszDeviceType should contain the device type in low word, and device ordinal in high word!
AmpOpenParms.pszDeviceType =
(PSZ) (MCI_DEVTYPE_AUDIO_AMPMIX | (iDeviceOrd << 16));
iOpenMode = MCI_WAIT | MCI_OPEN_TYPE_ID;
if (bOpenShared)
iOpenMode |= MCI_OPEN_SHAREABLE;
rc = mciSendCommand(0, MCI_OPEN, iOpenMode, (PVOID) & AmpOpenParms, 0);
111
if (rc != MCIERR_SUCCESS) { // No audio available??
112
113
114
115
DART_CloseDevice(_this);
SDL_SetError("DART: Couldn't open audio device.");
return 0;
}
116
117
// Save the device ID we got from DART!
// We will use this in the next calls!
118
_this->hidden->iCurrDeviceOrd = iDeviceOrd = AmpOpenParms.usDeviceID;
119
120
// Determine the audio parameters from the AudioSpec
121
122
if (_this->spec.channels > 4)
_this->spec.channels = 4;
124
while ((!valid_datatype) && (test_format)) {
125
_this->spec.format = test_format;
126
valid_datatype = 1;
127
switch (test_format) {
128
129
130
case AUDIO_U8:
// Unsigned 8 bit audio data
iSilence = 0x80;
131
_this->hidden->iCurrBits = iBits = 8;
132
133
134
135
136
break;
case AUDIO_S16LSB:
// Signed 16 bit audio data
iSilence = 0x00;
137
_this->hidden->iCurrBits = iBits = 16;
138
break;
139
140
141
// !!! FIXME: int32?
142
143
144
145
default:
valid_datatype = 0;
test_format = SDL_NextAudioFormat();
break;
149
if (!valid_datatype) { // shouldn't happen, but just in case...
150
// Close DART, and exit with error code!
151
DART_CloseDevice(_this);
152
SDL_SetError("Unsupported audio format");
156
157
_this->hidden->iCurrFreq = iFreq = _this->spec.freq;
_this->hidden->iCurrChannels = iChannels = _this->spec.channels;
158
/* Update the fragment size as size in bytes */
159
160
SDL_CalculateAudioSpec(&_this->spec);
_this->hidden->iCurrBufSize = iBufSize = _this->spec.size;
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
// Now query this device if it supports the given freq/bits/channels!
SDL_memset(&(_this->hidden->MixSetupParms), 0,
sizeof(MCI_MIXSETUP_PARMS));
_this->hidden->MixSetupParms.ulBitsPerSample = iBits;
_this->hidden->MixSetupParms.ulFormatTag = MCI_WAVE_FORMAT_PCM;
_this->hidden->MixSetupParms.ulSamplesPerSec = iFreq;
_this->hidden->MixSetupParms.ulChannels = iChannels;
_this->hidden->MixSetupParms.ulFormatMode = MCI_PLAY;
_this->hidden->MixSetupParms.ulDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
_this->hidden->MixSetupParms.pmixEvent = DARTEventFunc;
rc = mciSendCommand(iDeviceOrd, MCI_MIXSETUP,
MCI_WAIT | MCI_MIXSETUP_QUERYMODE,
&(_this->hidden->MixSetupParms), 0);
if (rc != MCIERR_SUCCESS) { // The device cannot handle this format!
// Close DART, and exit with error code!
177
DART_CloseDevice(_this);
178
SDL_SetError("Audio device doesn't support requested audio format");
180
181
182
183
184
185
}
// The device can handle this format, so initialize!
rc = mciSendCommand(iDeviceOrd, MCI_MIXSETUP,
MCI_WAIT | MCI_MIXSETUP_INIT,
&(_this->hidden->MixSetupParms), 0);
if (rc != MCIERR_SUCCESS) { // The device could not be opened!
186
// Close DART, and exit with error code!
187
DART_CloseDevice(_this);
188
SDL_SetError("Audio device could not be set up");
190
}
191
192
193
194
195
196
197
// Ok, the device is initialized.
// Now we should allocate buffers. For this, we need a place where
// the buffer descriptors will be:
_this->hidden->pMixBuffers =
(MCI_MIX_BUFFER *) SDL_malloc(sizeof(MCI_MIX_BUFFER) * iNumBufs);
if (!(_this->hidden->pMixBuffers)) { // Not enough memory!
// Close DART, and exit with error code!
198
199
200
DART_CloseDevice(_this);
SDL_OutOfMemory();
return 0;
201
202
203
204
205
206
207
208
209
210
211
212
213
214
}
// Now that we have the place for buffer list, we can ask DART for the
// buffers!
_this->hidden->BufferParms.ulNumBuffers = iNumBufs; // Number of buffers
_this->hidden->BufferParms.ulBufferSize = iBufSize; // each with this size
_this->hidden->BufferParms.pBufList = _this->hidden->pMixBuffers; // getting descriptorts into this list
// Allocate buffers!
rc = mciSendCommand(iDeviceOrd, MCI_BUFFER,
MCI_WAIT | MCI_ALLOCATE_MEMORY,
&(_this->hidden->BufferParms), 0);
if ((rc != MCIERR_SUCCESS)
|| (iNumBufs != _this->hidden->BufferParms.ulNumBuffers)
|| (_this->hidden->BufferParms.ulBufferSize == 0)) { // Could not allocate memory!
// Close DART, and exit with error code!
215
DART_CloseDevice(_this);
216
SDL_SetError("DART could not allocate buffers");
219
220
_this->hidden->iCurrNumBufs = iNumBufs;
221
// Ok, we have all the buffers allocated, let's mark them!
222
{
223
224
225
226
227
228
229
int i;
for (i = 0; i < iNumBufs; i++) {
pMixBufferDesc pBufferDesc =
(pMixBufferDesc) SDL_malloc(sizeof(tMixBufferDesc));;
// Check if this buffer was really allocated by DART
if ((!(_this->hidden->pMixBuffers[i].pBuffer))
|| (!pBufferDesc)) { // Wrong buffer!
230
DART_CloseDevice(_this);
231
SDL_SetError("Error at internal buffer check");
233
234
235
236
237
238
239
240
241
242
243
244
245
}
pBufferDesc->iBufferUsage = BUFFER_EMPTY;
pBufferDesc->pSDLAudioDevice = _this;
_this->hidden->pMixBuffers[i].ulBufferLength =
_this->hidden->BufferParms.ulBufferSize;
_this->hidden->pMixBuffers[i].ulUserParm = (ULONG) pBufferDesc; // User parameter: Description of buffer
_this->hidden->pMixBuffers[i].ulFlags = 0; // Some stuff should be flagged here for DART, like end of
// audio data, but as we will continously send
// audio data, there will be no end.:)
SDL_memset(_this->hidden->pMixBuffers[i].pBuffer, iSilence,
iBufSize);
}
246
}
247
248
249
250
251
252
_this->hidden->iNextFreeBuffer = 0;
_this->hidden->iLastPlayedBuf = -1;
// Create event semaphore
if (DosCreateEventSem
(NULL, &(_this->hidden->hevAudioBufferPlayed), 0, FALSE) != NO_ERROR)
{
253
DART_CloseDevice(_this);
254
SDL_SetError("Could not create event semaphore");
259
260
}
262
DART_ThreadInit(_THIS)
263
{
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
/* Increase the priority of this thread to make sure that
the audio will be continuous all the time! */
#ifdef USE_DOSSETPRIORITY
if (SDL_getenv("SDL_USE_TIMECRITICAL_AUDIO")) {
#ifdef DEBUG_BUILD
printf
("[DART_ThreadInit] : Setting priority to TimeCritical+0! (TID%d)\n",
SDL_ThreadID());
#endif
DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
} else {
#ifdef DEBUG_BUILD
printf
("[DART_ThreadInit] : Setting priority to ForegroundServer+0! (TID%d)\n",
SDL_ThreadID());
#endif
DosSetPriority(PRTYS_THREAD, PRTYC_FOREGROUNDSERVER, 0, 0);
}
#endif
283
284
285
}
/* This function waits until it is possible to write a full sound buffer */
286
287
static void
DART_WaitDevice(_THIS)
288
{
289
290
291
292
293
294
295
296
297
298
299
300
301
302
int i;
pMixBufferDesc pBufDesc;
ULONG ulPostCount;
DosResetEventSem(_this->hidden->hevAudioBufferPlayed, &ulPostCount);
// If there is already an empty buffer, then return now!
for (i = 0; i < _this->hidden->iCurrNumBufs; i++) {
pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[i].ulUserParm;
if (pBufDesc->iBufferUsage == BUFFER_EMPTY)
return;
}
// If there is no empty buffer, wait for one to be empty!
DosWaitEventSem(_this->hidden->hevAudioBufferPlayed, 1000); // Wait max 1 sec!!! Important!
return;
303
304
}
305
306
static void
DART_PlayDevice(_THIS)
307
{
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
int iFreeBuf = _this->hidden->iNextFreeBuffer;
pMixBufferDesc pBufDesc;
pBufDesc =
(pMixBufferDesc) _this->hidden->pMixBuffers[iFreeBuf].ulUserParm;
pBufDesc->iBufferUsage = BUFFER_USED;
// Send it to DART to be queued
_this->hidden->MixSetupParms.pmixWrite(_this->hidden->MixSetupParms.
ulMixHandle,
&(_this->hidden->
pMixBuffers[iFreeBuf]), 1);
_this->hidden->iLastPlayedBuf = iFreeBuf;
iFreeBuf = (iFreeBuf + 1) % _this->hidden->iCurrNumBufs;
_this->hidden->iNextFreeBuffer = iFreeBuf;
323
324
}
325
326
static Uint8 *
DART_GetDeviceBuf(_THIS)
327
{
328
329
330
int iFreeBuf;
Uint8 *pResult;
pMixBufferDesc pBufDesc;
331
332
333
334
335
336
337
338
339
340
341
342
343
344
if (_this) {
if (_this->hidden) {
iFreeBuf = _this->hidden->iNextFreeBuffer;
pBufDesc =
(pMixBufferDesc) _this->hidden->pMixBuffers[iFreeBuf].
ulUserParm;
if (pBufDesc) {
if (pBufDesc->iBufferUsage == BUFFER_EMPTY) {
pResult = _this->hidden->pMixBuffers[iFreeBuf].pBuffer;
return pResult;
}
} else
345
printf("[DART_GetDeviceBuf] : ERROR! pBufDesc = %p\n",
346
347
pBufDesc);
} else
348
printf("[DART_GetDeviceBuf] : ERROR! _this->hidden = %p\n",
349
_this->hidden);
350
} else
351
printf("[DART_GetDeviceBuf] : ERROR! _this = %p\n", _this);
352
return NULL;
353
354
}
356
DART_WaitDone(_THIS)
357
{
358
pMixBufferDesc pBufDesc;
359
360
361
362
ULONG ulPostCount = 0;
APIRET rc = NO_ERROR;
pBufDesc = (pMixBufferDesc)
363
_this->hidden->pMixBuffers[_this->hidden->iLastPlayedBuf].ulUserParm;
364
365
366
367
368
while ((pBufDesc->iBufferUsage != BUFFER_EMPTY) && (rc == NO_ERROR)) {
DosResetEventSem(_this->hidden->hevAudioBufferPlayed, &ulPostCount);
rc = DosWaitEventSem(_this->hidden->hevAudioBufferPlayed, 1000); // 1 sec timeout! Important!
}
369
370
}
371
372
static void
DART_CloseDevice(_THIS)
373
{
374
375
MCI_GENERIC_PARMS GenericParms;
int rc;
377
378
379
380
381
382
if (_this->hidden != NULL) {
// Stop DART playback
if (_this->hidden->iCurrDeviceOrd) {
rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_STOP,
MCI_WAIT, &GenericParms, 0);
383
#ifdef SFX_DEBUG_BUILD
384
385
386
387
if (rc != MCIERR_SUCCESS) {
printf("Could not stop DART playback!\n");
fflush(stdout);
}
388
#endif
389
390
391
392
393
394
395
396
397
398
399
400
}
// Close event semaphore
if (_this->hidden->hevAudioBufferPlayed) {
DosCloseEventSem(_this->hidden->hevAudioBufferPlayed);
_this->hidden->hevAudioBufferPlayed = 0;
}
// Free memory of buffer descriptions
for (i = 0; i < _this->hidden->iCurrNumBufs; i++) {
SDL_free((void *) (_this->hidden->pMixBuffers[i].ulUserParm));
_this->hidden->pMixBuffers[i].ulUserParm = 0;
}
_this->hidden->iCurrNumBufs = 0;
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
// Deallocate buffers
if (_this->hidden->iCurrDeviceOrd) {
rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_BUFFER,
MCI_WAIT | MCI_DEALLOCATE_MEMORY,
&(_this->hidden->BufferParms), 0);
}
// Free bufferlist
if (_this->hidden->pMixBuffers != NULL) {
SDL_free(_this->hidden->pMixBuffers);
_this->hidden->pMixBuffers = NULL;
}
// Close dart
if (_this->hidden->iCurrDeviceOrd) {
rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_CLOSE,
MCI_WAIT, &(GenericParms), 0);
}
_this->hidden->iCurrDeviceOrd = 0;
419
420
421
422
SDL_free(_this->hidden);
_this->hidden = NULL;
}
423
424
425
}
427
DART_Init(SDL_AudioDriverImpl * impl)
428
{
429
/* Set the function pointers */
430
431
432
433
434
435
436
impl->OpenDevice = DART_OpenDevice;
impl->ThreadInit = DART_ThreadInit;
impl->WaitDevice = DART_WaitDevice;
impl->GetDeviceBuf = DART_GetDeviceBuf;
impl->PlayDevice = DART_PlayDevice;
impl->WaitDone = DART_WaitDone;
impl->CloseDevice = DART_CloseDevice;
437
impl->OnlyHasDefaultOutputDevice = 1; /* !!! FIXME: is this right? */
440
441
}
443
AudioBootStrap DART_bootstrap = {
444
"dart", "OS/2 Direct Audio RouTines (DART)", DART_Init, 0
445
446
};
447
/* vi: set ts=4 sw=4 expandtab: */