gcc 4.0 signedness warning fixes and uninitialized vector fixes
[xonotic/darkplaces.git] / snd_mix.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
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 */
20 // snd_mix.c -- portable code to mix sounds
21
22 #include "quakedef.h"
23 #include "snd_main.h"
24
25 typedef struct
26 {
27         int left;
28         int right;
29 } portable_samplepair_t;
30
31 // LordHavoc: was 512, expanded to 2048
32 #define PAINTBUFFER_SIZE 2048
33 portable_samplepair_t paintbuffer[PAINTBUFFER_SIZE];
34
35 // FIXME: this desyncs with the video too easily
36 extern qboolean cl_capturevideo_active;
37 extern void SCR_CaptureVideo_SoundFrame(qbyte *bufstereo16le, size_t length, int rate);
38 void S_CaptureAVISound(portable_samplepair_t *buf, size_t length)
39 {
40         int n;
41         size_t i;
42         qbyte out[PAINTBUFFER_SIZE * 4];
43         if (!cl_capturevideo_active)
44                 return;
45         // write the sound buffer as little endian 16bit interleaved stereo
46         for(i = 0;i < length;i++)
47         {
48                 n = buf[i].left;
49                 n = bound(-32768, n, 32767);
50                 out[i*4+0] = n & 0xFF;
51                 out[i*4+1] = (n >> 8) & 0xFF;
52                 n = buf[i].right;
53                 n = bound(-32768, n, 32767);
54                 out[i*4+2] = n & 0xFF;
55                 out[i*4+3] = (n >> 8) & 0xFF;
56         }
57         SCR_CaptureVideo_SoundFrame(out, length, shm->format.speed);
58 }
59
60 // TODO: rewrite this function
61 void S_TransferPaintBuffer(int endtime)
62 {
63         void *pbuf;
64         if ((pbuf = S_LockBuffer()))
65         {
66                 int i;
67                 int *snd_p;
68                 int lpaintedtime;
69                 int snd_linear_count;
70                 int val;
71                 snd_p = (int *) paintbuffer;
72                 lpaintedtime = paintedtime;
73                 if (shm->format.width == 2)
74                 {
75                         // 16bit
76                         short *snd_out;
77                         if (shm->format.channels == 2)
78                         {
79                                 // 16bit 2 channels (stereo)
80                                 while (lpaintedtime < endtime)
81                                 {
82                                         // handle recirculating buffer issues
83                                         i = lpaintedtime & ((shm->samples >> 1) - 1);
84                                         snd_out = (short *) pbuf + (i << 1);
85                                         snd_linear_count = (shm->samples >> 1) - i;
86                                         if (snd_linear_count > endtime - lpaintedtime)
87                                                 snd_linear_count = endtime - lpaintedtime;
88                                         snd_linear_count <<= 1;
89                                         if (snd_swapstereo.value)
90                                         {
91                                                 for (i = 0;i < snd_linear_count;i += 2)
92                                                 {
93                                                         snd_out[i    ] = bound(-32768, snd_p[i + 1], 32767);
94                                                         snd_out[i + 1] = bound(-32768, snd_p[i    ], 32767);
95                                                 }
96                                         }
97                                         else
98                                         {
99                                                 for (i = 0;i < snd_linear_count;i += 2)
100                                                 {
101                                                         snd_out[i    ] = bound(-32768, snd_p[i    ], 32767);
102                                                         snd_out[i + 1] = bound(-32768, snd_p[i + 1], 32767);
103                                                 }
104                                         }
105                                         snd_p += snd_linear_count;
106                                         lpaintedtime += (snd_linear_count >> 1);
107                                 }
108                         }
109                         else
110                         {
111                                 // 16bit 1 channel (mono)
112                                 while (lpaintedtime < endtime)
113                                 {
114                                         // handle recirculating buffer issues
115                                         i = lpaintedtime & (shm->samples - 1);
116                                         snd_out = (short *) pbuf + i;
117                                         snd_linear_count = shm->samples - i;
118                                         if (snd_linear_count > endtime - lpaintedtime)
119                                                 snd_linear_count = endtime - lpaintedtime;
120                                         for (i = 0;i < snd_linear_count;i++)
121                                         {
122                                                 val = (snd_p[i * 2 + 0] + snd_p[i * 2 + 1]) >> 1;
123                                                 snd_out[i] = bound(-32768, val, 32767);
124                                         }
125                                         snd_p += snd_linear_count << 1;
126                                         lpaintedtime += snd_linear_count;
127                                 }
128                         }
129                 }
130                 else
131                 {
132                         // 8bit
133                         unsigned char *snd_out;
134                         if (shm->format.channels == 2)
135                         {
136                                 // 8bit 2 channels (stereo)
137                                 while (lpaintedtime < endtime)
138                                 {
139                                         // handle recirculating buffer issues
140                                         i = lpaintedtime & ((shm->samples >> 1) - 1);
141                                         snd_out = (unsigned char *) pbuf + (i << 1);
142                                         snd_linear_count = (shm->samples >> 1) - i;
143                                         if (snd_linear_count > endtime - lpaintedtime)
144                                                 snd_linear_count = endtime - lpaintedtime;
145                                         snd_linear_count <<= 1;
146                                         if (snd_swapstereo.value)
147                                         {
148                                                 for (i = 0;i < snd_linear_count;i += 2)
149                                                 {
150                                                         val = (snd_p[i + 1] >> 8) + 128;
151                                                         snd_out[i    ] = bound(0, val, 255);
152                                                         val = (snd_p[i    ] >> 8) + 128;
153                                                         snd_out[i + 1] = bound(0, val, 255);
154                                                 }
155                                         }
156                                         else
157                                         {
158                                                 for (i = 0;i < snd_linear_count;i += 2)
159                                                 {
160                                                         val = (snd_p[i    ] >> 8) + 128;
161                                                         snd_out[i    ] = bound(0, val, 255);
162                                                         val = (snd_p[i + 1] >> 8) + 128;
163                                                         snd_out[i + 1] = bound(0, val, 255);
164                                                 }
165                                         }
166                                         snd_p += snd_linear_count;
167                                         lpaintedtime += (snd_linear_count >> 1);
168                                 }
169                         }
170                         else
171                         {
172                                 // 8bit 1 channel (mono)
173                                 while (lpaintedtime < endtime)
174                                 {
175                                         // handle recirculating buffer issues
176                                         i = lpaintedtime & (shm->samples - 1);
177                                         snd_out = (unsigned char *) pbuf + i;
178                                         snd_linear_count = shm->samples - i;
179                                         if (snd_linear_count > endtime - lpaintedtime)
180                                                 snd_linear_count = endtime - lpaintedtime;
181                                         for (i = 0;i < snd_linear_count;i++)
182                                         {
183                                                 val = ((snd_p[i * 2] + snd_p[i * 2 + 1]) >> 9) + 128;
184                                                 snd_out[i    ] = bound(0, val, 255);
185                                         }
186                                         snd_p += snd_linear_count << 1;
187                                         lpaintedtime += snd_linear_count;
188                                 }
189                         }
190                 }
191
192                 S_UnlockBuffer();
193         }
194 }
195
196
197 /*
198 ===============================================================================
199
200 CHANNEL MIXING
201
202 ===============================================================================
203 */
204
205 qboolean SND_PaintChannelFrom8 (channel_t *ch, int endtime);
206 qboolean SND_PaintChannelFrom16 (channel_t *ch, int endtime);
207
208 void S_PaintChannels(int endtime)
209 {
210         unsigned int i;
211         int end;
212         channel_t *ch;
213         sfx_t *sfx;
214         int ltime, count;
215
216         while (paintedtime < endtime)
217         {
218                 // if paintbuffer is smaller than DMA buffer
219                 end = endtime;
220                 if (endtime - paintedtime > PAINTBUFFER_SIZE)
221                         end = paintedtime + PAINTBUFFER_SIZE;
222
223                 // clear the paint buffer
224                 memset (&paintbuffer, 0, (end - paintedtime) * sizeof (paintbuffer[0]));
225
226                 // paint in the channels.
227                 ch = channels;
228                 for (i=0; i<total_channels ; i++, ch++)
229                 {
230                         sfx = ch->sfx;
231                         if (!sfx)
232                                 continue;
233                         if (!ch->leftvol && !ch->rightvol)
234                                 continue;
235                         if (!S_LoadSound (sfx, true))
236                                 continue;
237
238                         // if the channel is paused
239                         if (ch->flags & CHANNELFLAG_PAUSED)
240                         {
241                                 int pausedtime = end - paintedtime;
242                                 ch->lastptime += pausedtime;
243                                 ch->end += pausedtime;
244                                 continue;
245                         }
246
247                         // if the sound hasn't been painted last time, update his position
248                         if (ch->lastptime < paintedtime)
249                         {
250                                 ch->pos += paintedtime - ch->lastptime;
251
252                                 // If the sound should have ended by then
253                                 if ((unsigned int)ch->pos > sfx->total_length)
254                                 {
255                                         int loopstart;
256
257                                         if (ch->flags & CHANNELFLAG_FORCELOOP)
258                                                 loopstart = 0;
259                                         else
260                                                 loopstart = -1;
261                                         if (sfx->loopstart >= 0)
262                                                 loopstart = sfx->loopstart;
263
264                                         // If the sound is looped
265                                         if (loopstart >= 0)
266                                                 ch->pos = (ch->pos - sfx->total_length) % (sfx->total_length - loopstart) + loopstart;
267                                         else
268                                                 ch->pos = sfx->total_length;
269                                         ch->end = paintedtime + sfx->total_length - ch->pos;
270                                 }
271                         }
272
273                         ltime = paintedtime;
274                         while (ltime < end)
275                         {
276                                 qboolean stop_paint;
277
278                                 // paint up to end
279                                 if (ch->end < end)
280                                         count = (int)ch->end - ltime;
281                                 else
282                                         count = end - ltime;
283
284                                 if (count > 0)
285                                 {
286                                         if (ch->leftvol > 255)
287                                                 ch->leftvol = 255;
288                                         if (ch->rightvol > 255)
289                                                 ch->rightvol = 255;
290
291                                         if (sfx->format.width == 1)
292                                                 stop_paint = !SND_PaintChannelFrom8 (ch, count);
293                                         else
294                                                 stop_paint = !SND_PaintChannelFrom16 (ch, count);
295
296                                         if (!stop_paint)
297                                         {
298                                                 ltime += count;
299                                                 ch->lastptime = ltime;
300                                         }
301                                 }
302                                 else
303                                         stop_paint = false;
304
305                                 if (ltime >= ch->end)
306                                 {
307                                         // if at end of loop, restart
308                                         if ((sfx->loopstart >= 0 || (ch->flags & CHANNELFLAG_FORCELOOP)) && !stop_paint)
309                                         {
310                                                 ch->pos = bound(0, sfx->loopstart, (int)sfx->total_length - 1);
311                                                 ch->end = ltime + sfx->total_length - ch->pos;
312                                         }
313                                         // channel just stopped
314                                         else
315                                                 stop_paint = true;
316                                 }
317
318                                 if (stop_paint)
319                                 {
320                                         S_StopChannel (ch - channels);
321                                         break;
322                                 }
323                         }
324                 }
325
326                 // transfer out according to DMA format
327                 S_CaptureAVISound (paintbuffer, end - paintedtime);
328                 S_TransferPaintBuffer(end);
329                 paintedtime = end;
330         }
331 }
332
333
334 // TODO: Try to merge SND_PaintChannelFrom8 and SND_PaintChannelFrom16
335 qboolean SND_PaintChannelFrom8 (channel_t *ch, int count)
336 {
337         int snd_vol, leftvol, rightvol;
338         const signed char *sfx;
339         const sfxbuffer_t *sb;
340         int i;
341
342         // If this channel manages its own volume
343         if (ch->flags & CHANNELFLAG_FULLVOLUME)
344                 snd_vol = 256;
345         else
346                 snd_vol = volume.value * 256;
347
348         leftvol = ch->leftvol * snd_vol;
349         rightvol = ch->rightvol * snd_vol;
350
351         sb = ch->sfx->fetcher->getsb (ch, ch->pos, count);
352         if (sb == NULL)
353                 return false;
354
355         // Stereo sound support
356         if (ch->sfx->format.channels == 2)
357         {
358                 sfx = (signed char *)sb->data + (ch->pos - sb->offset) * 2;
359                 for (i = 0;i < count;i++)
360                 {
361                         paintbuffer[i].left += (*sfx++ * leftvol) >> 8;
362                         paintbuffer[i].right += (*sfx++ * rightvol) >> 8;
363                 }
364         }
365         else
366         {
367                 sfx = (signed char *)sb->data + ch->pos - sb->offset;
368                 for (i = 0;i < count;i++)
369                 {
370                         paintbuffer[i].left += (*sfx * leftvol) >> 8;
371                         paintbuffer[i].right += (*sfx++ * rightvol) >> 8;
372                 }
373         }
374         ch->pos += count;
375         return true;
376 }
377
378 qboolean SND_PaintChannelFrom16 (channel_t *ch, int count)
379 {
380         int snd_vol, leftvol, rightvol;
381         signed short *sfx;
382         const sfxbuffer_t *sb;
383         int i;
384
385         // If this channel manages its own volume
386         if (ch->flags & CHANNELFLAG_FULLVOLUME)
387                 snd_vol = 256;
388         else
389                 snd_vol = volume.value * 256;
390
391         leftvol = ch->leftvol * snd_vol;
392         rightvol = ch->rightvol * snd_vol;
393
394         sb = ch->sfx->fetcher->getsb (ch, ch->pos, count);
395         if (sb == NULL)
396                 return false;
397
398         // Stereo sound support
399         if (ch->sfx->format.channels == 2)
400         {
401                 sfx = (signed short *)sb->data + (ch->pos - sb->offset) * 2;
402
403                 for (i=0 ; i<count ; i++)
404                 {
405                         paintbuffer[i].left += (*sfx++ * leftvol) >> 16;
406                         paintbuffer[i].right += (*sfx++ * rightvol) >> 16;
407                 }
408         }
409         else
410         {
411                 sfx = (signed short *)sb->data + ch->pos - sb->offset;
412
413                 for (i=0 ; i<count ; i++)
414                 {
415                         paintbuffer[i].left += (*sfx * leftvol) >> 16;
416                         paintbuffer[i].right += (*sfx++ * rightvol) >> 16;
417                 }
418         }
419
420         ch->pos += count;
421         return true;
422 }
423