This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_ahiaudio.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
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
24
25
/* Allow access to a raw mixing buffer (for AmigaOS) */
26
#include "SDL_audio.h"
27
#include "../SDL_audio_c.h"
28
#include "SDL_ahiaudio.h"
29
30
/* Audio driver functions */
31
32
33
34
35
static int AHI_OpenAudio(_THIS, SDL_AudioSpec * spec);
static void AHI_WaitAudio(_THIS);
static void AHI_PlayAudio(_THIS);
static Uint8 *AHI_GetAudioBuf(_THIS);
static void AHI_CloseAudio(_THIS);
36
37
#ifndef __SASC
38
39
#define mymalloc(x) AllocVec(x,MEMF_PUBLIC)
#define myfree FreeVec
40
#else
41
42
#define mymalloc malloc
#define myfree free
43
44
45
46
#endif
/* Audio driver bootstrap functions */
48
Audio_Available(void)
50
51
52
53
int ok = 0;
struct MsgPort *p;
struct AHIRequest *req;
54
if (p = CreateMsgPort()) {
56
57
58
(struct AHIRequest *) CreateIORequest(p,
sizeof(struct
AHIRequest))) {
59
60
req->ahir_Version = 4;
61
62
if (!OpenDevice(AHINAME, 0, (struct IORequest *) req, NULL)) {
D(bug("AHI available.\n"));
64
CloseDevice((struct IORequest *) req);
66
DeleteIORequest((struct IORequest *) req);
68
DeleteMsgPort(p);
71
D(if (!ok) bug("AHI not available\n"));
73
74
}
76
Audio_DeleteDevice(SDL_AudioDevice * device)
78
79
SDL_free(device->hidden);
SDL_free(device);
80
81
}
82
static SDL_AudioDevice *
83
Audio_CreateDevice(int devindex)
85
SDL_AudioDevice *this;
86
87
#ifndef NO_AMIGADEBUG
88
D(bug("AHI created...\n"));
89
90
#endif
91
/* Initialize all variables that we clean on shutdown */
92
this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
94
SDL_memset(this, 0, (sizeof *this));
95
this->hidden = (struct SDL_PrivateAudioData *)
96
SDL_malloc((sizeof *this->hidden));
97
98
}
if ((this == NULL) || (this->hidden == NULL)) {
99
SDL_OutOfMemory();
101
SDL_free(this);
102
103
104
}
return (0);
}
105
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
106
107
108
109
110
111
112
113
114
115
116
/* Set the function pointers */
this->OpenAudio = AHI_OpenAudio;
this->WaitAudio = AHI_WaitAudio;
this->PlayAudio = AHI_PlayAudio;
this->GetAudioBuf = AHI_GetAudioBuf;
this->CloseAudio = AHI_CloseAudio;
this->free = Audio_DeleteDevice;
return this;
117
118
119
}
AudioBootStrap AHI_bootstrap = {
120
"AHI", Audio_Available, Audio_CreateDevice
121
122
123
};
125
AHI_WaitAudio(_THIS)
126
{
127
128
if (!CheckIO((struct IORequest *) audio_req[current_buffer])) {
WaitIO((struct IORequest *) audio_req[current_buffer]);
129
130
// AbortIO((struct IORequest *)audio_req[current_buffer]);
}
131
132
}
134
AHI_PlayAudio(_THIS)
135
{
136
if (playing > 1)
137
WaitIO((struct IORequest *) audio_req[current_buffer]);
138
139
140
141
142
143
144
145
146
147
148
149
150
151
/* Write the audio data out */
audio_req[current_buffer]->ahir_Std.io_Message.mn_Node.ln_Pri = 60;
audio_req[current_buffer]->ahir_Std.io_Data = mixbuf[current_buffer];
audio_req[current_buffer]->ahir_Std.io_Length = this->hidden->size;
audio_req[current_buffer]->ahir_Std.io_Offset = 0;
audio_req[current_buffer]->ahir_Std.io_Command = CMD_WRITE;
audio_req[current_buffer]->ahir_Frequency = this->hidden->freq;
audio_req[current_buffer]->ahir_Volume = 0x10000;
audio_req[current_buffer]->ahir_Type = this->hidden->type;
audio_req[current_buffer]->ahir_Position = 0x8000;
audio_req[current_buffer]->ahir_Link =
(playing > 0 ? audio_req[current_buffer ^ 1] : NULL);
152
SendIO((struct IORequest *) audio_req[current_buffer]);
153
154
155
current_buffer ^= 1;
playing++;
156
157
}
159
AHI_GetAudioBuf(_THIS)
160
{
161
return (mixbuf[current_buffer]);
162
163
}
165
AHI_CloseAudio(_THIS)
166
{
167
D(bug("Closing audio...\n"));
171
172
if (audio_req[0]) {
if (audio_req[1]) {
173
D(bug("Break req[1]...\n"));
175
176
AbortIO((struct IORequest *) audio_req[1]);
WaitIO((struct IORequest *) audio_req[1]);
179
D(bug("Break req[0]...\n"));
181
182
AbortIO((struct IORequest *) audio_req[0]);
WaitIO((struct IORequest *) audio_req[0]);
184
if (audio_req[1]) {
185
186
187
D(bug("Break AGAIN req[1]...\n"));
AbortIO((struct IORequest *) audio_req[1]);
WaitIO((struct IORequest *) audio_req[1]);
189
190
// Double abort to be sure to break the dbuffering process.
191
SDL_Delay(200);
193
194
195
196
197
198
D(bug("Reqs breaked, closing device...\n"));
CloseDevice((struct IORequest *) audio_req[0]);
D(bug("Device closed, freeing memory...\n"));
myfree(audio_req[1]);
D(bug("Memory freed, deleting IOReq...\n"));
DeleteIORequest((struct IORequest *) audio_req[0]);
199
200
201
audio_req[0] = audio_req[1] = NULL;
}
202
D(bug("Freeing mixbuf[0]...\n"));
203
if (mixbuf[0] != NULL) {
204
myfree(mixbuf[0]);
205
206
207
208
// SDL_FreeAudioMem(mixbuf[0]);
mixbuf[0] = NULL;
}
209
D(bug("Freeing mixbuf[1]...\n"));
210
if (mixbuf[1] != NULL) {
211
myfree(mixbuf[1]);
212
213
214
215
// SDL_FreeAudioMem(mixbuf[1]);
mixbuf[1] = NULL;
}
216
D(bug("Freeing audio_port...\n"));
217
218
if (audio_port != NULL) {
219
DeleteMsgPort(audio_port);
220
221
audio_port = NULL;
}
222
D(bug("...done!\n"));
223
224
}
226
AHI_OpenAudio(_THIS, SDL_AudioSpec * spec)
227
228
229
{
// int width;
230
D(bug("AHI opening...\n"));
231
232
233
234
235
236
/* Determine the audio parameters from the AudioSpec */
switch (spec->format & 0xFF) {
case 8:
{ /* Signed 8 bit audio data */
237
D(bug("Samples a 8 bit...\n"));
238
239
240
241
242
243
244
245
246
247
248
spec->format = AUDIO_S8;
this->hidden->bytespersample = 1;
if (spec->channels < 2)
this->hidden->type = AHIST_M8S;
else
this->hidden->type = AHIST_S8S;
}
break;
case 16:
{ /* Signed 16 bit audio data */
249
D(bug("Samples a 16 bit...\n"));
250
251
252
253
254
255
256
257
258
259
260
spec->format = AUDIO_S16MSB;
this->hidden->bytespersample = 2;
if (spec->channels < 2)
this->hidden->type = AHIST_M16S;
else
this->hidden->type = AHIST_S16S;
}
break;
default:
{
261
SDL_SetError("Unsupported audio format");
262
263
264
265
266
return (-1);
}
}
if (spec->channels != 1 && spec->channels != 2) {
267
268
D(bug("Wrong channel number!\n"));
SDL_SetError("Channel number non supported");
269
270
271
return -1;
}
272
D(bug("Before CalculateAudioSpec\n"));
273
/* Update the fragment size as size in bytes */
274
SDL_CalculateAudioSpec(spec);
276
D(bug("Before CreateMsgPort\n"));
278
279
if (!(audio_port = CreateMsgPort())) {
SDL_SetError("Unable to create a MsgPort");
280
281
282
return -1;
}
283
D(bug("Before CreateIORequest\n"));
284
285
286
if (!
(audio_req[0] =
287
288
289
290
(struct AHIRequest *) CreateIORequest(audio_port,
sizeof(struct AHIRequest)))) {
SDL_SetError("Unable to create an AHIRequest");
DeleteMsgPort(audio_port);
291
292
293
294
295
return -1;
}
audio_req[0]->ahir_Version = 4;
296
297
298
299
if (OpenDevice(AHINAME, 0, (struct IORequest *) audio_req[0], NULL)) {
SDL_SetError("Unable to open AHI device!\n");
DeleteIORequest((struct IORequest *) audio_req[0]);
DeleteMsgPort(audio_port);
300
301
302
return -1;
}
303
D(bug("AFTER opendevice\n"));
304
305
306
307
308
/* Set output frequency and size */
this->hidden->freq = spec->freq;
this->hidden->size = spec->size;
309
D(bug("Before buffer allocation\n"));
310
311
/* Allocate mixing buffer */
312
313
mixbuf[0] = (Uint8 *) mymalloc(spec->size);
mixbuf[1] = (Uint8 *) mymalloc(spec->size);
315
D(bug("Before audio_req allocation\n"));
317
318
if (!(audio_req[1] = mymalloc(sizeof(struct AHIRequest)))) {
SDL_OutOfMemory();
319
320
321
return (-1);
}
322
D(bug("Before audio_req memcpy\n"));
324
SDL_memcpy(audio_req[1], audio_req[0], sizeof(struct AHIRequest));
325
326
if (mixbuf[0] == NULL || mixbuf[1] == NULL) {
327
SDL_OutOfMemory();
328
329
330
return (-1);
}
331
D(bug("Before mixbuf memset\n"));
333
334
SDL_memset(mixbuf[0], spec->silence, spec->size);
SDL_memset(mixbuf[1], spec->silence, spec->size);
335
336
337
338
current_buffer = 0;
playing = 0;
339
340
341
342
D(bug
("AHI opened: freq:%ld mixbuf:%lx/%lx buflen:%ld bits:%ld channels:%ld\n",
spec->freq, mixbuf[0], mixbuf[1], spec->size,
this->hidden->bytespersample * 8, spec->channels));
343
344
345
/* We're ready to rock and roll. :-) */
return (0);
346
}
347
348
/* vi: set ts=4 sw=4 expandtab: */