Mercurial > sdl-ios-xcode

comparison src/audio/dsp/SDL_dspaudio.c @ 1668:4da1ee79c9af SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
more tweaking indent options
author Sam Lantinga <slouken@libsdl.org>
date Mon, 29 May 2006 04:04:35 +0000
parents 782fd950bd46
children
comparison
equal deleted inserted replaced
1667:1fddae038bc8 1668:4da1ee79c9af
56 56
57 /* Open the audio device for playback, and don't block if busy */ 57 /* Open the audio device for playback, and don't block if busy */
58 #define OPEN_FLAGS (O_WRONLY|O_NONBLOCK) 58 #define OPEN_FLAGS (O_WRONLY|O_NONBLOCK)
59 59
60 /* Audio driver functions */ 60 /* Audio driver functions */
61 static int DSP_OpenAudio (_THIS, SDL_AudioSpec * spec); 61 static int DSP_OpenAudio(_THIS, SDL_AudioSpec * spec);
62 static void DSP_WaitAudio (_THIS); 62 static void DSP_WaitAudio(_THIS);
63 static void DSP_PlayAudio (_THIS); 63 static void DSP_PlayAudio(_THIS);
64 static Uint8 *DSP_GetAudioBuf (_THIS); 64 static Uint8 *DSP_GetAudioBuf(_THIS);
65 static void DSP_CloseAudio (_THIS); 65 static void DSP_CloseAudio(_THIS);
66 66
67 /* Audio driver bootstrap functions */ 67 /* Audio driver bootstrap functions */
68 68
69 static int 69 static int
70 Audio_Available (void) 70 Audio_Available(void)
71 { 71 {
72 int fd; 72 int fd;
73 int available; 73 int available;
74 74
75 available = 0; 75 available = 0;
76 fd = SDL_OpenAudioPath (NULL, 0, OPEN_FLAGS, 0); 76 fd = SDL_OpenAudioPath(NULL, 0, OPEN_FLAGS, 0);
77 if (fd >= 0) { 77 if (fd >= 0) {
78 available = 1; 78 available = 1;
79 close (fd); 79 close(fd);
80 } 80 }
81 return (available); 81 return (available);
82 } 82 }
83 83
84 static void 84 static void
85 Audio_DeleteDevice (SDL_AudioDevice * device) 85 Audio_DeleteDevice(SDL_AudioDevice * device)
86 { 86 {
87 SDL_free (device->hidden); 87 SDL_free(device->hidden);
88 SDL_free (device); 88 SDL_free(device);
89 } 89 }
90 90
91 static SDL_AudioDevice * 91 static SDL_AudioDevice *
92 Audio_CreateDevice (int devindex) 92 Audio_CreateDevice(int devindex)
93 { 93 {
94 SDL_AudioDevice *this; 94 SDL_AudioDevice *this;
95 95
96 /* Initialize all variables that we clean on shutdown */ 96 /* Initialize all variables that we clean on shutdown */
97 this = (SDL_AudioDevice *) SDL_malloc (sizeof (SDL_AudioDevice)); 97 this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
98 if (this) { 98 if (this) {
99 SDL_memset (this, 0, (sizeof *this)); 99 SDL_memset(this, 0, (sizeof *this));
100 this->hidden = (struct SDL_PrivateAudioData *) 100 this->hidden = (struct SDL_PrivateAudioData *)
101 SDL_malloc ((sizeof *this->hidden)); 101 SDL_malloc((sizeof *this->hidden));
102 } 102 }
103 if ((this == NULL) || (this->hidden == NULL)) { 103 if ((this == NULL) || (this->hidden == NULL)) {
104 SDL_OutOfMemory (); 104 SDL_OutOfMemory();
105 if (this) { 105 if (this) {
106 SDL_free (this); 106 SDL_free(this);
107 } 107 }
108 return (0); 108 return (0);
109 } 109 }
110 SDL_memset (this->hidden, 0, (sizeof *this->hidden)); 110 SDL_memset(this->hidden, 0, (sizeof *this->hidden));
111 audio_fd = -1; 111 audio_fd = -1;
112 112
113 /* Set the function pointers */ 113 /* Set the function pointers */
114 this->OpenAudio = DSP_OpenAudio; 114 this->OpenAudio = DSP_OpenAudio;
115 this->WaitAudio = DSP_WaitAudio; 115 this->WaitAudio = DSP_WaitAudio;
127 Audio_Available, Audio_CreateDevice 127 Audio_Available, Audio_CreateDevice
128 }; 128 };
129 129
130 /* This function waits until it is possible to write a full sound buffer */ 130 /* This function waits until it is possible to write a full sound buffer */
131 static void 131 static void
132 DSP_WaitAudio (_THIS) 132 DSP_WaitAudio(_THIS)
133 { 133 {
134 /* Not needed at all since OSS handles waiting automagically */ 134 /* Not needed at all since OSS handles waiting automagically */
135 } 135 }
136 136
137 static void 137 static void
138 DSP_PlayAudio (_THIS) 138 DSP_PlayAudio(_THIS)
139 { 139 {
140 if (write (audio_fd, mixbuf, mixlen) == -1) { 140 if (write(audio_fd, mixbuf, mixlen) == -1) {
141 perror ("Audio write"); 141 perror("Audio write");
142 this->enabled = 0; 142 this->enabled = 0;
143 } 143 }
144 #ifdef DEBUG_AUDIO 144 #ifdef DEBUG_AUDIO
145 fprintf (stderr, "Wrote %d bytes of audio data\n", mixlen); 145 fprintf(stderr, "Wrote %d bytes of audio data\n", mixlen);
146 #endif 146 #endif
147 } 147 }
148 148
149 static Uint8 * 149 static Uint8 *
150 DSP_GetAudioBuf (_THIS) 150 DSP_GetAudioBuf(_THIS)
151 { 151 {
152 return (mixbuf); 152 return (mixbuf);
153 } 153 }
154 154
155 static void 155 static void
156 DSP_CloseAudio (_THIS) 156 DSP_CloseAudio(_THIS)
157 { 157 {
158 if (mixbuf != NULL) { 158 if (mixbuf != NULL) {
159 SDL_FreeAudioMem (mixbuf); 159 SDL_FreeAudioMem(mixbuf);
160 mixbuf = NULL; 160 mixbuf = NULL;
161 } 161 }
162 if (audio_fd >= 0) { 162 if (audio_fd >= 0) {
163 close (audio_fd); 163 close(audio_fd);
164 audio_fd = -1; 164 audio_fd = -1;
165 } 165 }
166 } 166 }
167 167
168 static int 168 static int
169 DSP_OpenAudio (_THIS, SDL_AudioSpec * spec) 169 DSP_OpenAudio(_THIS, SDL_AudioSpec * spec)
170 { 170 {
171 char audiodev[1024]; 171 char audiodev[1024];
172 int format; 172 int format;
173 int value; 173 int value;
174 int frag_spec; 174 int frag_spec;
175 Uint16 test_format; 175 Uint16 test_format;
176 176
177 /* Open the audio device */ 177 /* Open the audio device */
178 audio_fd = SDL_OpenAudioPath (audiodev, sizeof (audiodev), OPEN_FLAGS, 0); 178 audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
179 if (audio_fd < 0) { 179 if (audio_fd < 0) {
180 SDL_SetError ("Couldn't open %s: %s", audiodev, strerror (errno)); 180 SDL_SetError("Couldn't open %s: %s", audiodev, strerror(errno));
181 return (-1); 181 return (-1);
182 } 182 }
183 mixbuf = NULL; 183 mixbuf = NULL;
184 184
185 /* Make the file descriptor use blocking writes with fcntl() */ 185 /* Make the file descriptor use blocking writes with fcntl() */
186 { 186 {
187 long flags; 187 long flags;
188 flags = fcntl (audio_fd, F_GETFL); 188 flags = fcntl(audio_fd, F_GETFL);
189 flags &= ~O_NONBLOCK; 189 flags &= ~O_NONBLOCK;
190 if (fcntl (audio_fd, F_SETFL, flags) < 0) { 190 if (fcntl(audio_fd, F_SETFL, flags) < 0) {
191 SDL_SetError ("Couldn't set audio blocking mode"); 191 SDL_SetError("Couldn't set audio blocking mode");
192 DSP_CloseAudio (this); 192 DSP_CloseAudio(this);
193 return (-1); 193 return (-1);
194 } 194 }
195 } 195 }
196 196
197 /* Get a list of supported hardware formats */ 197 /* Get a list of supported hardware formats */
198 if (ioctl (audio_fd, SNDCTL_DSP_GETFMTS, &value) < 0) { 198 if (ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &value) < 0) {
199 perror ("SNDCTL_DSP_GETFMTS"); 199 perror("SNDCTL_DSP_GETFMTS");
200 SDL_SetError ("Couldn't get audio format list"); 200 SDL_SetError("Couldn't get audio format list");
201 DSP_CloseAudio (this); 201 DSP_CloseAudio(this);
202 return (-1); 202 return (-1);
203 } 203 }
204 204
205 /* Try for a closest match on audio format */ 205 /* Try for a closest match on audio format */
206 format = 0; 206 format = 0;
207 for (test_format = SDL_FirstAudioFormat (spec->format); 207 for (test_format = SDL_FirstAudioFormat(spec->format);
208 !format && test_format;) { 208 !format && test_format;) {
209 #ifdef DEBUG_AUDIO 209 #ifdef DEBUG_AUDIO
210 fprintf (stderr, "Trying format 0x%4.4x\n", test_format); 210 fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
211 #endif 211 #endif
212 switch (test_format) { 212 switch (test_format) {
213 case AUDIO_U8: 213 case AUDIO_U8:
214 if (value & AFMT_U8) { 214 if (value & AFMT_U8) {
215 format = AFMT_U8; 215 format = AFMT_U8;
249 default: 249 default:
250 format = 0; 250 format = 0;
251 break; 251 break;
252 } 252 }
253 if (!format) { 253 if (!format) {
254 test_format = SDL_NextAudioFormat (); 254 test_format = SDL_NextAudioFormat();
255 } 255 }
256 } 256 }
257 if (format == 0) { 257 if (format == 0) {
258 SDL_SetError ("Couldn't find any hardware audio formats"); 258 SDL_SetError("Couldn't find any hardware audio formats");
259 DSP_CloseAudio (this); 259 DSP_CloseAudio(this);
260 return (-1); 260 return (-1);
261 } 261 }
262 spec->format = test_format; 262 spec->format = test_format;
263 263
264 /* Set the audio format */ 264 /* Set the audio format */
265 value = format; 265 value = format;
266 if ((ioctl (audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) || 266 if ((ioctl(audio_fd, SNDCTL_DSP_SETFMT, &value) < 0) || (value != format)) {
267 (value != format)) { 267 perror("SNDCTL_DSP_SETFMT");
268 perror ("SNDCTL_DSP_SETFMT"); 268 SDL_SetError("Couldn't set audio format");
269 SDL_SetError ("Couldn't set audio format"); 269 DSP_CloseAudio(this);
270 DSP_CloseAudio (this);
271 return (-1); 270 return (-1);
272 } 271 }
273 272
274 /* Set the number of channels of output */ 273 /* Set the number of channels of output */
275 value = spec->channels; 274 value = spec->channels;
276 if (ioctl (audio_fd, SNDCTL_DSP_CHANNELS, &value) < 0) { 275 if (ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &value) < 0) {
277 perror ("SNDCTL_DSP_CHANNELS"); 276 perror("SNDCTL_DSP_CHANNELS");
278 SDL_SetError ("Cannot set the number of channels"); 277 SDL_SetError("Cannot set the number of channels");
279 DSP_CloseAudio (this); 278 DSP_CloseAudio(this);
280 return (-1); 279 return (-1);
281 } 280 }
282 spec->channels = value; 281 spec->channels = value;
283 282
284 /* Set the DSP frequency */ 283 /* Set the DSP frequency */
285 value = spec->freq; 284 value = spec->freq;
286 if (ioctl (audio_fd, SNDCTL_DSP_SPEED, &value) < 0) { 285 if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &value) < 0) {
287 perror ("SNDCTL_DSP_SPEED"); 286 perror("SNDCTL_DSP_SPEED");
288 SDL_SetError ("Couldn't set audio frequency"); 287 SDL_SetError("Couldn't set audio frequency");
289 DSP_CloseAudio (this); 288 DSP_CloseAudio(this);
290 return (-1); 289 return (-1);
291 } 290 }
292 spec->freq = value; 291 spec->freq = value;
293 292
294 /* Calculate the final parameters for this audio specification */ 293 /* Calculate the final parameters for this audio specification */
295 SDL_CalculateAudioSpec (spec); 294 SDL_CalculateAudioSpec(spec);
296 295
297 /* Determine the power of two of the fragment size */ 296 /* Determine the power of two of the fragment size */
298 for (frag_spec = 0; (0x01U << frag_spec) < spec->size; ++frag_spec); 297 for (frag_spec = 0; (0x01U << frag_spec) < spec->size; ++frag_spec);
299 if ((0x01U << frag_spec) != spec->size) { 298 if ((0x01U << frag_spec) != spec->size) {
300 SDL_SetError ("Fragment size must be a power of two"); 299 SDL_SetError("Fragment size must be a power of two");
301 DSP_CloseAudio (this); 300 DSP_CloseAudio(this);
302 return (-1); 301 return (-1);
303 } 302 }
304 frag_spec |= 0x00020000; /* two fragments, for low latency */ 303 frag_spec |= 0x00020000; /* two fragments, for low latency */
305 304
306 /* Set the audio buffering parameters */ 305 /* Set the audio buffering parameters */
307 #ifdef DEBUG_AUDIO 306 #ifdef DEBUG_AUDIO
308 fprintf (stderr, "Requesting %d fragments of size %d\n", 307 fprintf(stderr, "Requesting %d fragments of size %d\n",
309 (frag_spec >> 16), 1 << (frag_spec & 0xFFFF)); 308 (frag_spec >> 16), 1 << (frag_spec & 0xFFFF));
310 #endif 309 #endif
311 if (ioctl (audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_spec) < 0) { 310 if (ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_spec) < 0) {
312 perror ("SNDCTL_DSP_SETFRAGMENT"); 311 perror("SNDCTL_DSP_SETFRAGMENT");
313 } 312 }
314 #ifdef DEBUG_AUDIO 313 #ifdef DEBUG_AUDIO
315 { 314 {
316 audio_buf_info info; 315 audio_buf_info info;
317 ioctl (audio_fd, SNDCTL_DSP_GETOSPACE, &info); 316 ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info);
318 fprintf (stderr, "fragments = %d\n", info.fragments); 317 fprintf(stderr, "fragments = %d\n", info.fragments);
319 fprintf (stderr, "fragstotal = %d\n", info.fragstotal); 318 fprintf(stderr, "fragstotal = %d\n", info.fragstotal);
320 fprintf (stderr, "fragsize = %d\n", info.fragsize); 319 fprintf(stderr, "fragsize = %d\n", info.fragsize);
321 fprintf (stderr, "bytes = %d\n", info.bytes); 320 fprintf(stderr, "bytes = %d\n", info.bytes);
322 } 321 }
323 #endif 322 #endif
324 323
325 /* Allocate mixing buffer */ 324 /* Allocate mixing buffer */
326 mixlen = spec->size; 325 mixlen = spec->size;
327 mixbuf = (Uint8 *) SDL_AllocAudioMem (mixlen); 326 mixbuf = (Uint8 *) SDL_AllocAudioMem(mixlen);
328 if (mixbuf == NULL) { 327 if (mixbuf == NULL) {
329 DSP_CloseAudio (this); 328 DSP_CloseAudio(this);
330 return (-1); 329 return (-1);
331 } 330 }
332 SDL_memset (mixbuf, spec->silence, spec->size); 331 SDL_memset(mixbuf, spec->silence, spec->size);
333 332
334 /* Get the parent process id (we're the parent of the audio thread) */ 333 /* Get the parent process id (we're the parent of the audio thread) */
335 parent = getpid (); 334 parent = getpid();
336 335
337 /* We're ready to rock and roll. :-) */ 336 /* We're ready to rock and roll. :-) */
338 return (0); 337 return (0);
339 } 338 }
340 339