This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_dart.c
458 lines (401 loc) · 15.6 KB
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.
14
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
}
70
return TRUE;
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
91
MCI_AMP_OPEN_PARMS AmpOpenParms;
MCI_GENERIC_PARMS GenericParms;
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;
92
93
94
95
96
97
98
99
100
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc((sizeof *this->hidden));
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
101
102
103
104
105
106
107
108
109
110
111
// 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);
112
113
114
115
116
if (rc != MCIERR_SUCCESS) { // No audio available??
DART_CloseDevice(this);
return 0;
}
117
118
// Save the device ID we got from DART!
// We will use this in the next calls!
119
_this->hidden->iCurrDeviceOrd = iDeviceOrd = AmpOpenParms.usDeviceID;
120
121
// Determine the audio parameters from the AudioSpec
122
123
if (this->spec.channels > 4)
this->spec.channels = 4;
124
125
while ((!valid_datatype) && (test_format)) {
126
this->spec.format = test_format;
127
valid_datatype = 1;
128
switch (test_format) {
129
130
131
case AUDIO_U8:
// Unsigned 8 bit audio data
iSilence = 0x80;
132
_this->hidden->iCurrBits = iBits = 8;
133
134
135
136
137
break;
case AUDIO_S16LSB:
// Signed 16 bit audio data
iSilence = 0x00;
138
_this->hidden->iCurrBits = iBits = 16;
139
break;
140
141
142
// !!! FIXME: int32?
143
144
145
146
default:
valid_datatype = 0;
test_format = SDL_NextAudioFormat();
break;
147
148
149
}
}
150
if (!valid_datatype) { // shouldn't happen, but just in case...
151
// Close DART, and exit with error code!
152
DART_CloseDevice(this);
153
SDL_SetError("Unsupported audio format");
154
return 0;
155
}
156
157
158
_this->hidden->iCurrFreq = iFreq = this->spec.freq;
_this->hidden->iCurrChannels = iChannels = this->spec.channels;
159
/* Update the fragment size as size in bytes */
160
161
SDL_CalculateAudioSpec(&this->spec);
_this->hidden->iCurrBufSize = iBufSize = this->spec.size;
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
// 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!
178
DART_CloseDevice(this);
179
SDL_SetError("Audio device doesn't support requested audio format");
180
return 0;
181
182
183
184
185
186
}
// 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!
187
// Close DART, and exit with error code!
188
DART_CloseDevice(this);
189
SDL_SetError("Audio device could not be set up");
190
return 0;
191
}
192
193
194
195
196
197
198
// 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!
199
200
201
DART_CloseDevice(this);
SDL_OutOfMemory();
return 0;
202
203
204
205
206
207
208
209
210
211
212
213
214
215
}
// 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!
216
DART_CloseDevice(this);
217
SDL_SetError("DART could not allocate buffers");
218
return 0;
219
}
220
221
_this->hidden->iCurrNumBufs = iNumBufs;
222
// Ok, we have all the buffers allocated, let's mark them!
223
{
224
225
226
227
228
229
230
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!
231
DART_CloseDevice(this);
232
SDL_SetError("Error at internal buffer check");
233
return 0;
234
235
236
237
238
239
240
241
242
243
244
245
246
}
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);
}
247
}
248
249
250
251
252
253
_this->hidden->iNextFreeBuffer = 0;
_this->hidden->iLastPlayedBuf = -1;
// Create event semaphore
if (DosCreateEventSem
(NULL, &(_this->hidden->hevAudioBufferPlayed), 0, FALSE) != NO_ERROR)
{
254
DART_CloseDevice(this);
255
SDL_SetError("Could not create event semaphore");
256
return 0;
257
258
}
259
return 1;
260
261
}
262
static void
263
DART_ThreadInit(_THIS)
264
{
265
266
267
268
269
270
/* 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
271
("[DART_ThreadInit] : Setting priority to TimeCritical+0! (TID%d)\n",
272
273
274
275
276
277
SDL_ThreadID());
#endif
DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
} else {
#ifdef DEBUG_BUILD
printf
278
("[DART_ThreadInit] : Setting priority to ForegroundServer+0! (TID%d)\n",
279
280
281
282
283
SDL_ThreadID());
#endif
DosSetPriority(PRTYS_THREAD, PRTYC_FOREGROUNDSERVER, 0, 0);
}
#endif
284
285
286
}
/* This function waits until it is possible to write a full sound buffer */
287
288
static void
DART_WaitDevice(_THIS)
289
{
290
291
292
293
294
295
296
297
298
299
300
301
302
303
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;
304
305
}
306
307
static void
DART_PlayDevice(_THIS)
308
{
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
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;
324
325
}
326
327
static Uint8 *
DART_GetDeviceBuf(_THIS)
328
{
329
330
331
int iFreeBuf;
Uint8 *pResult;
pMixBufferDesc pBufDesc;
332
333
334
335
336
337
338
339
340
341
342
343
344
345
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
346
printf("[DART_GetDeviceBuf] : ERROR! pBufDesc = %p\n",
347
348
pBufDesc);
} else
349
printf("[DART_GetDeviceBuf] : ERROR! _this->hidden = %p\n",
350
_this->hidden);
351
} else
352
printf("[DART_GetDeviceBuf] : ERROR! _this = %p\n", _this);
353
return NULL;
354
355
}
356
static void
357
DART_WaitDone(_THIS)
358
{
359
pMixBufferDesc pBufDesc;
360
361
362
363
364
ULONG ulPostCount = 0;
APIRET rc = NO_ERROR;
pBufDesc = (pMixBufferDesc)
_this->hidden->pMixBuffers[_this->hidden->iLastPlayedBuf].ulUserParm;
365
366
367
368
369
while ((pBufDesc->iBufferUsage != BUFFER_EMPTY) && (rc == NO_ERROR)) {
DosResetEventSem(_this->hidden->hevAudioBufferPlayed, &ulPostCount);
rc = DosWaitEventSem(_this->hidden->hevAudioBufferPlayed, 1000); // 1 sec timeout! Important!
}
370
371
}
372
373
static void
DART_CloseDevice(_THIS)
374
{
375
376
MCI_GENERIC_PARMS GenericParms;
int rc;
377
int i;
378
379
380
381
382
383
if (_this->hidden != NULL) {
// Stop DART playback
if (_this->hidden->iCurrDeviceOrd) {
rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_STOP,
MCI_WAIT, &GenericParms, 0);
384
#ifdef SFX_DEBUG_BUILD
385
386
387
388
if (rc != MCIERR_SUCCESS) {
printf("Could not stop DART playback!\n");
fflush(stdout);
}
389
#endif
390
}
391
392
393
394
395
396
// Close event semaphore
if (_this->hidden->hevAudioBufferPlayed) {
DosCloseEventSem(_this->hidden->hevAudioBufferPlayed);
_this->hidden->hevAudioBufferPlayed = 0;
}
397
398
399
400
401
402
403
// 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;
404
405
406
407
408
409
410
// Deallocate buffers
if (_this->hidden->iCurrDeviceOrd) {
rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_BUFFER,
MCI_WAIT | MCI_DEALLOCATE_MEMORY,
&(_this->hidden->BufferParms), 0);
}
411
412
413
414
415
416
// Free bufferlist
if (_this->hidden->pMixBuffers != NULL) {
SDL_free(_this->hidden->pMixBuffers);
_this->hidden->pMixBuffers = NULL;
}
417
418
419
420
421
422
423
// Close dart
if (_this->hidden->iCurrDeviceOrd) {
rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_CLOSE,
MCI_WAIT, &(GenericParms), 0);
}
_this->hidden->iCurrDeviceOrd = 0;
424
425
426
427
SDL_free(_this->hidden);
_this->hidden = NULL;
}
428
429
}
430
431
static int
DART_Available(void)
432
{
433
return 1; /* Always available on OS/2 Warp */
434
435
}
436
437
static int
DART_Init(SDL_AudioDriverImpl *impl)
438
{
439
/* Set the function pointers */
440
441
442
443
444
445
446
447
448
449
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;
impl->OnlyHasDefaultOutputDevice = 1; /* !!! FIXME: is this right? */
return 1;
450
451
}
452
453
AudioBootStrap DART_bootstrap = {
454
"dart", "OS/2 Direct Audio RouTines (DART)",
455
DART_Available, DART_Init, 0
456
457
};
458
/* vi: set ts=4 sw=4 expandtab: */