added support for snd_blocked (related to the snd_mutewhenidle cvar) in
[divverent/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 "quakedef.h"
20
21 #include <math.h>
22 #include <SDL.h>
23
24 #include "snd_main.h"
25
26
27 static unsigned int sdlaudiotime = 0;
28
29
30 // Note: SDL calls SDL_LockAudio() right before this function, so no need to lock the audio data here
31 static void Buffer_Callback (void *userdata, Uint8 *stream, int len)
32 {
33         unsigned int factor, RequestedFrames, MaxFrames, FrameCount;
34         unsigned int StartOffset, EndOffset;
35
36         factor = snd_renderbuffer->format.channels * snd_renderbuffer->format.width;
37         if ((unsigned int)len % factor != 0)
38                 Sys_Error("SDL sound: invalid buffer length passed to Buffer_Callback (%d bytes)\n", len);
39
40         RequestedFrames = (unsigned int)len / factor;
41
42         if (snd_usethreadedmixing)
43         {
44                 S_MixToBuffer(stream, RequestedFrames);
45                 if (snd_blocked)
46                         memset(stream, snd_renderbuffer->format.width == 1 ? 0x80 : 0, len);
47                 return;
48         }
49
50         // Transfert up to a chunk of samples from snd_renderbuffer to stream
51         MaxFrames = snd_renderbuffer->endframe - snd_renderbuffer->startframe;
52         if (MaxFrames > RequestedFrames)
53                 FrameCount = RequestedFrames;
54         else
55                 FrameCount = MaxFrames;
56         StartOffset = snd_renderbuffer->startframe % snd_renderbuffer->maxframes;
57         EndOffset = (snd_renderbuffer->startframe + FrameCount) % snd_renderbuffer->maxframes;
58         if (StartOffset > EndOffset)  // if the buffer wraps
59         {
60                 unsigned int PartialLength1, PartialLength2;
61
62                 PartialLength1 = (snd_renderbuffer->maxframes - StartOffset) * factor;
63                 memcpy(stream, &snd_renderbuffer->ring[StartOffset * factor], PartialLength1);
64
65                 PartialLength2 = FrameCount * factor - PartialLength1;
66                 memcpy(&stream[PartialLength1], &snd_renderbuffer->ring[0], PartialLength2);
67         }
68         else
69                 memcpy(stream, &snd_renderbuffer->ring[StartOffset * factor], FrameCount * factor);
70
71         snd_renderbuffer->startframe += FrameCount;
72
73         if (FrameCount < RequestedFrames && developer.integer >= 1000 && vid_activewindow)
74                 Con_Printf("SDL sound: %u sample frames missing\n", RequestedFrames - FrameCount);
75
76         sdlaudiotime += RequestedFrames;
77 }
78
79
80 /*
81 ====================
82 SndSys_Init
83
84 Create "snd_renderbuffer" with the proper sound format if the call is successful
85 May return a suggested format if the requested format isn't available
86 ====================
87 */
88 qboolean SndSys_Init (const snd_format_t* requested, snd_format_t* suggested)
89 {
90         unsigned int buffersize;
91         SDL_AudioSpec wantspec;
92         SDL_AudioSpec obtainspec;
93
94         snd_threaded = false;
95
96         Con_DPrint ("SndSys_Init: using the SDL module\n");
97
98         // Init the SDL Audio subsystem
99         if( SDL_InitSubSystem( SDL_INIT_AUDIO ) ) {
100                 Con_Print( "Initializing the SDL Audio subsystem failed!\n" );
101                 return false;
102         }
103
104         buffersize = (unsigned int)ceil((double)requested->speed / 20.0);
105
106         // Init the SDL Audio subsystem
107         wantspec.callback = Buffer_Callback;
108         wantspec.userdata = NULL;
109         wantspec.freq = requested->speed;
110         wantspec.format = ((requested->width == 1) ? AUDIO_U8 : AUDIO_S16SYS);
111         wantspec.channels = requested->channels;
112         wantspec.samples = CeilPowerOf2(buffersize);  // needs to be a power of 2 on some platforms.
113
114         Con_Printf("Wanted audio Specification:\n"
115                                 "\tChannels  : %i\n"
116                                 "\tFormat    : 0x%X\n"
117                                 "\tFrequency : %i\n"
118                                 "\tSamples   : %i\n",
119                                 wantspec.channels, wantspec.format, wantspec.freq, wantspec.samples);
120
121         if( SDL_OpenAudio( &wantspec, &obtainspec ) )
122         {
123                 Con_Printf( "Failed to open the audio device! (%s)\n", SDL_GetError() );
124                 return false;
125         }
126
127         Con_Printf("Obtained audio specification:\n"
128                                 "\tChannels  : %i\n"
129                                 "\tFormat    : 0x%X\n"
130                                 "\tFrequency : %i\n"
131                                 "\tSamples   : %i\n",
132                                 obtainspec.channels, obtainspec.format, obtainspec.freq, obtainspec.samples);
133
134         // If we haven't obtained what we wanted
135         if (wantspec.freq != obtainspec.freq ||
136                 wantspec.format != obtainspec.format ||
137                 wantspec.channels != obtainspec.channels)
138         {
139                 SDL_CloseAudio();
140
141                 // Pass the obtained format as a suggested format
142                 if (suggested != NULL)
143                 {
144                         suggested->speed = obtainspec.freq;
145                         // FIXME: check the format more carefully. There are plenty of unsupported cases
146                         suggested->width = ((obtainspec.format == AUDIO_U8) ? 1 : 2);
147                         suggested->channels = obtainspec.channels;
148                 }
149
150                 return false;
151         }
152
153         snd_threaded = true;
154
155         snd_renderbuffer = Snd_CreateRingBuffer(requested, 0, NULL);
156         if (snd_channellayout.integer == SND_CHANNELLAYOUT_AUTO)
157         {
158                 int newlayout;
159
160 #ifdef __linux__
161                 newlayout = SND_CHANNELLAYOUT_ALSA;
162 #else
163                 newlayout = SND_CHANNELLAYOUT_STANDARD;
164 #endif
165                 Cvar_SetValueQuick (&snd_channellayout, newlayout);
166         }
167
168         sdlaudiotime = 0;
169         SDL_PauseAudio( false );
170
171         return true;
172 }
173
174
175 /*
176 ====================
177 SndSys_Shutdown
178
179 Stop the sound card, delete "snd_renderbuffer" and free its other resources
180 ====================
181 */
182 void SndSys_Shutdown(void)
183 {
184         SDL_CloseAudio();
185
186         if (snd_renderbuffer != NULL)
187         {
188                 Mem_Free(snd_renderbuffer->ring);
189                 Mem_Free(snd_renderbuffer);
190                 snd_renderbuffer = NULL;
191         }
192 }
193
194
195 /*
196 ====================
197 SndSys_Submit
198
199 Submit the contents of "snd_renderbuffer" to the sound card
200 ====================
201 */
202 void SndSys_Submit (void)
203 {
204         // Nothing to do here (this sound module is callback-based)
205 }
206
207
208 /*
209 ====================
210 SndSys_GetSoundTime
211
212 Returns the number of sample frames consumed since the sound started
213 ====================
214 */
215 unsigned int SndSys_GetSoundTime (void)
216 {
217         return sdlaudiotime;
218 }
219
220
221 /*
222 ====================
223 SndSys_LockRenderBuffer
224
225 Get the exclusive lock on "snd_renderbuffer"
226 ====================
227 */
228 qboolean SndSys_LockRenderBuffer (void)
229 {
230         SDL_LockAudio();
231         return true;
232 }
233
234
235 /*
236 ====================
237 SndSys_UnlockRenderBuffer
238
239 Release the exclusive lock on "snd_renderbuffer"
240 ====================
241 */
242 void SndSys_UnlockRenderBuffer (void)
243 {
244         SDL_UnlockAudio();
245 }