Fix snd_null prototype for a function which broke the dedicated server
[xonotic/darkplaces.git] / snd_sdl.c
1 /*
2 Copyright (C) 2004 Andreas Kirsch
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18 */
19 #include <math.h>
20 #include <SDL.h>
21
22 #include "quakedef.h"
23
24 #include "snd_main.h"
25
26
27 static unsigned int sdlaudiotime = 0;
28 static int audio_device = 0;
29
30
31 // Note: SDL calls SDL_LockAudio() right before this function, so no need to lock the audio data here
32 static void Buffer_Callback (void *userdata, Uint8 *stream, int len)
33 {
34         unsigned int factor, RequestedFrames, MaxFrames, FrameCount;
35         unsigned int StartOffset, EndOffset;
36
37         factor = snd_renderbuffer->format.channels * snd_renderbuffer->format.width;
38         if ((unsigned int)len % factor != 0)
39                 Sys_Error("SDL sound: invalid buffer length passed to Buffer_Callback (%d bytes)\n", len);
40
41         RequestedFrames = (unsigned int)len / factor;
42
43         if (SndSys_LockRenderBuffer())
44         {
45                 if (snd_usethreadedmixing)
46                 {
47                         S_MixToBuffer(stream, RequestedFrames);
48                         if (snd_blocked)
49                                 memset(stream, snd_renderbuffer->format.width == 1 ? 0x80 : 0, len);
50                         SndSys_UnlockRenderBuffer();
51                         return;
52                 }
53
54                 // Transfert up to a chunk of samples from snd_renderbuffer to stream
55                 MaxFrames = snd_renderbuffer->endframe - snd_renderbuffer->startframe;
56                 if (MaxFrames > RequestedFrames)
57                         FrameCount = RequestedFrames;
58                 else
59                         FrameCount = MaxFrames;
60                 StartOffset = snd_renderbuffer->startframe % snd_renderbuffer->maxframes;
61                 EndOffset = (snd_renderbuffer->startframe + FrameCount) % snd_renderbuffer->maxframes;
62                 if (StartOffset > EndOffset)  // if the buffer wraps
63                 {
64                         unsigned int PartialLength1, PartialLength2;
65
66                         PartialLength1 = (snd_renderbuffer->maxframes - StartOffset) * factor;
67                         memcpy(stream, &snd_renderbuffer->ring[StartOffset * factor], PartialLength1);
68
69                         PartialLength2 = FrameCount * factor - PartialLength1;
70                         memcpy(&stream[PartialLength1], &snd_renderbuffer->ring[0], PartialLength2);
71
72                         // As of SDL 2.0 buffer needs to be fully initialized, so fill leftover part with silence
73                         // FIXME this is another place that assumes 8bit is always unsigned and others always signed
74                         memset(&stream[PartialLength1 + PartialLength2], snd_renderbuffer->format.width == 1 ? 0x80 : 0, len - (PartialLength1 + PartialLength2));
75                 }
76                 else
77                 {
78                         memcpy(stream, &snd_renderbuffer->ring[StartOffset * factor], FrameCount * factor);
79
80                         // As of SDL 2.0 buffer needs to be fully initialized, so fill leftover part with silence
81                         // FIXME this is another place that assumes 8bit is always unsigned and others always signed
82                         memset(&stream[FrameCount * factor], snd_renderbuffer->format.width == 1 ? 0x80 : 0, len - (FrameCount * factor));
83                 }
84
85                 snd_renderbuffer->startframe += FrameCount;
86
87                 if (FrameCount < RequestedFrames && developer_insane.integer && vid_activewindow)
88                         Con_DPrintf("SDL sound: %u sample frames missing\n", RequestedFrames - FrameCount);
89
90                 sdlaudiotime += RequestedFrames;
91
92                 SndSys_UnlockRenderBuffer();
93         }
94 }
95
96
97 /*
98 ====================
99 SndSys_Init
100
101 Create "snd_renderbuffer" with the proper sound format if the call is successful
102 May return a suggested format if the requested format isn't available
103 ====================
104 */
105 qboolean SndSys_Init (snd_format_t* fmt)
106 {
107         unsigned int buffersize;
108         SDL_AudioSpec wantspec;
109         SDL_AudioSpec obtainspec;
110
111         snd_threaded = false;
112
113         Con_DPrint ("SndSys_Init: using the SDL module\n");
114
115         // Init the SDL Audio subsystem
116         if( SDL_InitSubSystem( SDL_INIT_AUDIO ) ) {
117                 Con_Print( "Initializing the SDL Audio subsystem failed!\n" );
118                 return false;
119         }
120
121         buffersize = (unsigned int)ceil((double)fmt->speed / 25.0); // 2048 bytes on 24kHz to 48kHz
122
123         // Init the SDL Audio subsystem
124         memset(&wantspec, 0, sizeof(wantspec));
125         wantspec.callback = Buffer_Callback;
126         wantspec.userdata = NULL;
127         wantspec.freq = fmt->speed;
128         wantspec.format = fmt->width == 1 ? AUDIO_U8 : (fmt->width == 2 ? AUDIO_S16SYS : AUDIO_F32);
129         wantspec.channels = fmt->channels;
130         wantspec.samples = CeilPowerOf2(buffersize);  // needs to be a power of 2 on some platforms.
131
132         Con_Printf("Wanted audio Specification:\n"
133                                 "\tChannels  : %i\n"
134                                 "\tFormat    : 0x%X\n"
135                                 "\tFrequency : %i\n"
136                                 "\tSamples   : %i\n",
137                                 wantspec.channels, wantspec.format, wantspec.freq, wantspec.samples);
138
139         if ((audio_device = SDL_OpenAudioDevice(NULL, 0, &wantspec, &obtainspec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE)) == 0)
140         {
141                 Con_Printf( "Failed to open the audio device! (%s)\n", SDL_GetError() );
142                 return false;
143         }
144
145         Con_Printf("Obtained audio specification:\n"
146                                 "\tChannels  : %i\n"
147                                 "\tFormat    : 0x%X\n"
148                                 "\tFrequency : %i\n"
149                                 "\tSamples   : %i\n",
150                                 obtainspec.channels, obtainspec.format, obtainspec.freq, obtainspec.samples);
151
152         fmt->speed = obtainspec.freq;
153         fmt->channels = obtainspec.channels;
154
155         snd_threaded = true;
156
157         snd_renderbuffer = Snd_CreateRingBuffer(fmt, 0, NULL);
158         if (snd_channellayout.integer == SND_CHANNELLAYOUT_AUTO)
159                 Cvar_SetValueQuick (&snd_channellayout, SND_CHANNELLAYOUT_STANDARD);
160
161         sdlaudiotime = 0;
162         SDL_PauseAudioDevice(audio_device, 0);
163
164         return true;
165 }
166
167
168 /*
169 ====================
170 SndSys_Shutdown
171
172 Stop the sound card, delete "snd_renderbuffer" and free its other resources
173 ====================
174 */
175 void SndSys_Shutdown(void)
176 {
177         if (audio_device > 0) {
178                 SDL_CloseAudioDevice(audio_device);
179                 audio_device = 0;
180         }
181         if (snd_renderbuffer != NULL)
182         {
183                 Mem_Free(snd_renderbuffer->ring);
184                 Mem_Free(snd_renderbuffer);
185                 snd_renderbuffer = NULL;
186         }
187 }
188
189
190 /*
191 ====================
192 SndSys_Submit
193
194 Submit the contents of "snd_renderbuffer" to the sound card
195 ====================
196 */
197 void SndSys_Submit (void)
198 {
199         // Nothing to do here (this sound module is callback-based)
200 }
201
202
203 /*
204 ====================
205 SndSys_GetSoundTime
206
207 Returns the number of sample frames consumed since the sound started
208 ====================
209 */
210 unsigned int SndSys_GetSoundTime (void)
211 {
212         return sdlaudiotime;
213 }
214
215
216 /*
217 ====================
218 SndSys_LockRenderBuffer
219
220 Get the exclusive lock on "snd_renderbuffer"
221 ====================
222 */
223 qboolean SndSys_LockRenderBuffer (void)
224 {
225         SDL_LockAudioDevice(audio_device);
226         return true;
227 }
228
229
230 /*
231 ====================
232 SndSys_UnlockRenderBuffer
233
234 Release the exclusive lock on "snd_renderbuffer"
235 ====================
236 */
237 void SndSys_UnlockRenderBuffer (void)
238 {
239         SDL_UnlockAudioDevice(audio_device);
240 }
241
242 /*
243 ====================
244 SndSys_SendKeyEvents
245
246 Send keyboard events originating from the sound system (e.g. MIDI)
247 ====================
248 */
249 void SndSys_SendKeyEvents(void)
250 {
251         // not supported
252 }