snd_maxchannelvolume and snd_softclip
[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
21 #include "quakedef.h"
22 #include "snd_main.h"
23
24 extern cvar_t snd_softclip;
25
26 static portable_sampleframe_t paintbuffer[PAINTBUFFER_SIZE];
27 static portable_sampleframe_t paintbuffer_unswapped[PAINTBUFFER_SIZE];
28
29 extern speakerlayout_t snd_speakerlayout; // for querying the listeners
30
31 extern void SCR_CaptureVideo_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length);
32 static void S_CaptureAVISound(const portable_sampleframe_t *paintbuffer, size_t length)
33 {
34         size_t i;
35         unsigned int j;
36
37         if (!cls.capturevideo.active)
38                 return;
39
40         // undo whatever swapping the channel layout (swapstereo, ALSA) did
41         for(j = 0; j < snd_speakerlayout.channels; ++j)
42         {
43                 unsigned int j0 = snd_speakerlayout.listeners[j].channel_unswapped;
44                 for(i = 0; i < length; ++i)
45                         paintbuffer_unswapped[i].sample[j0] = paintbuffer[i].sample[j];
46         }
47
48         SCR_CaptureVideo_SoundFrame(paintbuffer_unswapped, length);
49 }
50
51 extern cvar_t snd_softclip;
52
53 static void S_SoftClipPaintBuffer(portable_sampleframe_t *painted_ptr, int nbframes, int width, int channels)
54 {
55         int i;
56
57         if((snd_softclip.integer == 1 && width <= 2) || snd_softclip.integer > 1)
58         {
59 #if 0
60 /* Soft clipping, the sound of a dream, thanks to Jon Wattes
61    post to Musicdsp.org */
62 #define SOFTCLIP(x) (x) = sin(bound(-M_PI/2, (x), M_PI/2)) * 0.25
63 #endif
64
65                 // let's do a simple limiter instead, seems to sound better
66                 static float maxvol = 0;
67                 maxvol = max(1.0f, maxvol * (1.0f - nbframes / snd_renderbuffer->format.speed));
68 #define SOFTCLIP(x) if((x)>maxvol) maxvol=(x); (x) /= maxvol;
69
70                 portable_sampleframe_t *p = painted_ptr;
71                 if (channels == 8)  // 7.1 surround
72                 {
73                         for (i = 0;i < nbframes;i++, p++)
74                         {
75                                 SOFTCLIP(p->sample[0]);
76                                 SOFTCLIP(p->sample[1]);
77                                 SOFTCLIP(p->sample[2]);
78                                 SOFTCLIP(p->sample[3]);
79                                 SOFTCLIP(p->sample[4]);
80                                 SOFTCLIP(p->sample[5]);
81                                 SOFTCLIP(p->sample[6]);
82                                 SOFTCLIP(p->sample[7]);
83                         }
84                 }
85                 else if (channels == 6)  // 5.1 surround
86                 {
87                         for (i = 0; i < nbframes; i++, p++)
88                         {
89                                 SOFTCLIP(p->sample[0]);
90                                 SOFTCLIP(p->sample[1]);
91                                 SOFTCLIP(p->sample[2]);
92                                 SOFTCLIP(p->sample[3]);
93                                 SOFTCLIP(p->sample[4]);
94                                 SOFTCLIP(p->sample[5]);
95                         }
96                 }
97                 else if (channels == 4)  // 4.0 surround
98                 {
99                         for (i = 0; i < nbframes; i++, p++)
100                         {
101                                 SOFTCLIP(p->sample[0]);
102                                 SOFTCLIP(p->sample[1]);
103                                 SOFTCLIP(p->sample[2]);
104                                 SOFTCLIP(p->sample[3]);
105                         }
106                 }
107                 else if (channels == 2)  // 2.0 stereo
108                 {
109                         for (i = 0; i < nbframes; i++, p++)
110                         {
111                                 SOFTCLIP(p->sample[0]);
112                                 SOFTCLIP(p->sample[1]);
113                         }
114                 }
115                 else if (channels == 1)  // 1.0 mono
116                 {
117                         for (i = 0; i < nbframes; i++, p++)
118                         {
119                                 SOFTCLIP(p->sample[0]);
120                         }
121                 }
122 #undef SOFTCLIP
123         }
124 }
125
126 static void S_ConvertPaintBuffer(portable_sampleframe_t *painted_ptr, void *rb_ptr, int nbframes, int width, int channels)
127 {
128         int i, val;
129
130         // FIXME: add 24bit and 32bit float formats
131         // FIXME: optimize with SSE intrinsics?
132         if (width == 2)  // 16bit
133         {
134                 short *snd_out = (short*)rb_ptr;
135                 if (channels == 8)  // 7.1 surround
136                 {
137                         for (i = 0;i < nbframes;i++, painted_ptr++)
138                         {
139                                 val = (int)(painted_ptr->sample[0] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
140                                 val = (int)(painted_ptr->sample[1] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
141                                 val = (int)(painted_ptr->sample[2] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
142                                 val = (int)(painted_ptr->sample[3] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
143                                 val = (int)(painted_ptr->sample[4] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
144                                 val = (int)(painted_ptr->sample[5] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
145                                 val = (int)(painted_ptr->sample[6] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
146                                 val = (int)(painted_ptr->sample[7] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
147                         }
148                 }
149                 else if (channels == 6)  // 5.1 surround
150                 {
151                         for (i = 0; i < nbframes; i++, painted_ptr++)
152                         {
153                                 val = (int)(painted_ptr->sample[0] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
154                                 val = (int)(painted_ptr->sample[1] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
155                                 val = (int)(painted_ptr->sample[2] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
156                                 val = (int)(painted_ptr->sample[3] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
157                                 val = (int)(painted_ptr->sample[4] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
158                                 val = (int)(painted_ptr->sample[5] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
159                         }
160                 }
161                 else if (channels == 4)  // 4.0 surround
162                 {
163                         for (i = 0; i < nbframes; i++, painted_ptr++)
164                         {
165                                 val = (int)(painted_ptr->sample[0] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
166                                 val = (int)(painted_ptr->sample[1] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
167                                 val = (int)(painted_ptr->sample[2] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
168                                 val = (int)(painted_ptr->sample[3] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
169                         }
170                 }
171                 else if (channels == 2)  // 2.0 stereo
172                 {
173                         for (i = 0; i < nbframes; i++, painted_ptr++)
174                         {
175                                 val = (int)(painted_ptr->sample[0] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
176                                 val = (int)(painted_ptr->sample[1] * 32768.0f);*snd_out++ = bound(-32768, val, 32767);
177                         }
178                 }
179                 else if (channels == 1)  // 1.0 mono
180                 {
181                         for (i = 0; i < nbframes; i++, painted_ptr++)
182                         {
183                                 val = (int)((painted_ptr->sample[0] + painted_ptr->sample[1]) * 16384.0f);*snd_out++ = bound(-32768, val, 32767);
184                         }
185                 }
186
187                 // noise is really really annoying
188                 if (cls.timedemo)
189                         memset(rb_ptr, 0, nbframes * channels * width);
190         }
191         else  // 8bit
192         {
193                 unsigned char *snd_out = (unsigned char*)rb_ptr;
194                 if (channels == 8)  // 7.1 surround
195                 {
196                         for (i = 0; i < nbframes; i++, painted_ptr++)
197                         {
198                                 val = (int)(painted_ptr->sample[0] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
199                                 val = (int)(painted_ptr->sample[1] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
200                                 val = (int)(painted_ptr->sample[2] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
201                                 val = (int)(painted_ptr->sample[3] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
202                                 val = (int)(painted_ptr->sample[4] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
203                                 val = (int)(painted_ptr->sample[5] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
204                                 val = (int)(painted_ptr->sample[6] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
205                                 val = (int)(painted_ptr->sample[7] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
206                         }
207                 }
208                 else if (channels == 6)  // 5.1 surround
209                 {
210                         for (i = 0; i < nbframes; i++, painted_ptr++)
211                         {
212                                 val = (int)(painted_ptr->sample[0] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
213                                 val = (int)(painted_ptr->sample[1] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
214                                 val = (int)(painted_ptr->sample[2] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
215                                 val = (int)(painted_ptr->sample[3] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
216                                 val = (int)(painted_ptr->sample[4] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
217                                 val = (int)(painted_ptr->sample[5] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
218                         }
219                 }
220                 else if (channels == 4)  // 4.0 surround
221                 {
222                         for (i = 0; i < nbframes; i++, painted_ptr++)
223                         {
224                                 val = (int)(painted_ptr->sample[0] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
225                                 val = (int)(painted_ptr->sample[1] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
226                                 val = (int)(painted_ptr->sample[2] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
227                                 val = (int)(painted_ptr->sample[3] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
228                         }
229                 }
230                 else if (channels == 2)  // 2.0 stereo
231                 {
232                         for (i = 0; i < nbframes; i++, painted_ptr++)
233                         {
234                                 val = (int)(painted_ptr->sample[0] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
235                                 val = (int)(painted_ptr->sample[1] * 128.0f) + 128; *snd_out++ = bound(0, val, 255);
236                         }
237                 }
238                 else if (channels == 1)  // 1.0 mono
239                 {
240                         for (i = 0;i < nbframes;i++, painted_ptr++)
241                         {
242                                 val = (int)((painted_ptr->sample[0] + painted_ptr->sample[1]) * 64.0f) + 128; *snd_out++ = bound(0, val, 255);
243                         }
244                 }
245
246                 // noise is really really annoying
247                 if (cls.timedemo)
248                         memset(rb_ptr, 128, nbframes * channels);
249         }
250 }
251
252
253 /*
254 ===============================================================================
255
256 CHANNEL MIXING
257
258 ===============================================================================
259 */
260
261 void S_MixToBuffer(void *stream, unsigned int bufferframes)
262 {
263         int channelindex;
264         channel_t *ch;
265         int totalmixframes;
266         unsigned char *outbytes = (unsigned char *) stream;
267         sfx_t *sfx;
268         portable_sampleframe_t *paint;
269         int wantframes;
270         int i;
271         int count;
272         int fetched;
273         int fetch;
274         int istartframe;
275         int iendframe;
276         int ilengthframes;
277         int totallength;
278         int loopstart;
279         int indexfrac;
280         int indexfracstep;
281 #define S_FETCHBUFFERSIZE 4096
282         float fetchsampleframes[S_FETCHBUFFERSIZE*2];
283         const float *fetchsampleframe;
284         float vol[SND_LISTENERS];
285         float lerp[2];
286         float sample[3];
287         double posd;
288         double speedd;
289         float maxvol;
290         qboolean looping;
291         qboolean silent;
292
293         // mix as many times as needed to fill the requested buffer
294         while (bufferframes)
295         {
296                 // limit to the size of the paint buffer
297                 totalmixframes = min(bufferframes, PAINTBUFFER_SIZE);
298
299                 // clear the paint buffer
300                 memset(paintbuffer, 0, totalmixframes * sizeof(paintbuffer[0]));
301
302                 // paint in the channels.
303                 // channels with zero volumes still advance in time but don't paint.
304                 ch = channels;
305                 for (channelindex = 0;channelindex < (int)total_channels;channelindex++, ch++)
306                 {
307                         sfx = ch->sfx;
308                         if (sfx == NULL)
309                                 continue;
310                         if (!S_LoadSound (sfx, true))
311                                 continue;
312                         if (ch->flags & CHANNELFLAG_PAUSED)
313                                 continue;
314                         if (!sfx->total_length)
315                                 continue;
316
317                         // copy the channel information to the stack for reference, otherwise the
318                         // values might change during a mix if the spatializer is updating them
319                         // (note: this still may get some old and some new values!)
320                         posd = ch->position;
321                         speedd = ch->mixspeed * sfx->format.speed / snd_renderbuffer->format.speed;
322                         for (i = 0;i < SND_LISTENERS;i++)
323                                 vol[i] = ch->volume[i];
324
325                         // check total volume level, because we can skip some code on silent sounds but other code must still run (position updates mainly)
326                         maxvol = 0;
327                         for (i = 0;i < SND_LISTENERS;i++)
328                                 if(vol[i] > maxvol)
329                                         maxvol = vol[i];
330                         switch(snd_renderbuffer->format.width)
331                         {
332                                 case 1: // 8bpp
333                                         silent = maxvol < (1.0f / (256.0f));
334                                         // so silent it has zero effect
335                                         break;
336                                 case 2: // 16bpp
337                                         silent = maxvol < (1.0f / (65536.0f));
338                                         // so silent it has zero effect
339                                         break;
340                                 default: // floating point
341                                         silent = maxvol < 1.0e-13f;
342                                         // 130 dB is difference between hearing
343                                         // threshold and a jackhammer from
344                                         // working distance.
345                                         // therefore, anyone who turns up
346                                         // volume so much they notice this
347                                         // cutoff, likely already has their
348                                         // ear-drums blown out anyway.
349                                         break;
350                         }
351
352                         // when doing prologic mixing, some channels invert one side
353                         if (ch->prologic_invert == -1)
354                                 vol[1] *= -1.0f;
355
356                         // get some sfx info in a consistent form
357                         totallength = sfx->total_length;
358                         loopstart = (int)sfx->loopstart < totallength ? (int)sfx->loopstart : ((ch->flags & CHANNELFLAG_FORCELOOP) ? 0 : totallength);
359                         looping = loopstart < totallength;
360
361                         // do the actual paint now (may skip work if silent)
362                         paint = paintbuffer;
363                         wantframes = totalmixframes;
364                         istartframe = 0;
365                         for (wantframes = totalmixframes;wantframes > 0;posd += count * speedd, wantframes -= count)
366                         {
367                                 // check if this is a delayed sound
368                                 if (posd < 0)
369                                 {
370                                         // for a delayed sound we have to eat into the delay first
371                                         count = (int)floor(-posd / speedd) + 1;
372                                         count = bound(1, count, wantframes);
373                                         // let the for loop iterator apply the skip
374                                         continue;
375                                 }
376
377                                 // compute a fetch size that won't overflow our buffer
378                                 count = wantframes;
379                                 for (;;)
380                                 {
381                                         istartframe = (int)floor(posd);
382                                         iendframe = (int)floor(posd + (count-1) * speedd);
383                                         ilengthframes = count > 1 ? (iendframe - istartframe + 2) : 2;
384                                         if (ilengthframes <= S_FETCHBUFFERSIZE)
385                                                 break;
386                                         // reduce count by 25% and try again
387                                         count -= count >> 2;
388                                 }
389
390                                 // zero whole fetch buffer for safety
391                                 // (floating point noise from uninitialized memory = HORRIBLE)
392                                 // otherwise we would only need to clear the excess
393                                 if (!silent)
394                                         memset(fetchsampleframes, 0, ilengthframes*sfx->format.channels*sizeof(fetchsampleframes[0]));
395
396                                 // if looping, do multiple fetches
397                                 fetched = 0;
398                                 for (;;)
399                                 {
400                                         fetch = min(ilengthframes - fetched, totallength - istartframe);
401                                         if (fetch > 0)
402                                         {
403                                                 if (!silent)
404                                                         sfx->fetcher->getsamplesfloat(ch, sfx, istartframe, fetch, fetchsampleframes + fetched*sfx->format.channels);
405                                                 istartframe += fetch;
406                                                 fetched += fetch;
407                                         }
408                                         if (istartframe == totallength && looping && fetched < ilengthframes)
409                                         {
410                                                 // loop and fetch some more
411                                                 posd += loopstart - totallength;
412                                                 istartframe = loopstart;
413                                         }
414                                         else
415                                         {
416                                                 break;
417                                         }
418                                 }
419
420                                 // set up our fixedpoint resampling variables (float to int conversions are expensive so do not do one per sampleframe)
421                                 fetchsampleframe = fetchsampleframes;
422                                 indexfrac = (int)floor((posd - floor(posd)) * 65536.0);
423                                 indexfracstep = (int)floor(speedd * 65536.0);
424                                 if (!silent)
425                                 {
426                                         if (sfx->format.channels == 2)
427                                         {
428                                                 // music is stereo
429 #if SND_LISTENERS != 8
430 #error the following code only supports up to 8 channels, update it
431 #endif
432                                                 if (snd_speakerlayout.channels > 2)
433                                                 {
434                                                         // surround mixing
435                                                         for (i = 0;i < count;i++, paint++)
436                                                         {
437                                                                 lerp[1] = indexfrac * (1.0f / 65536.0f);
438                                                                 lerp[0] = 1.0f - lerp[1];
439                                                                 sample[0] = fetchsampleframe[0] * lerp[0] + fetchsampleframe[2] * lerp[1];
440                                                                 sample[1] = fetchsampleframe[1] * lerp[0] + fetchsampleframe[3] * lerp[1];
441                                                                 sample[2] = (sample[0] + sample[1]) * 0.5f;
442                                                                 paint->sample[0] += sample[0] * vol[0];
443                                                                 paint->sample[1] += sample[1] * vol[1];
444                                                                 paint->sample[2] += sample[0] * vol[2];
445                                                                 paint->sample[3] += sample[1] * vol[3];
446                                                                 paint->sample[4] += sample[2] * vol[4];
447                                                                 paint->sample[5] += sample[2] * vol[5];
448                                                                 paint->sample[6] += sample[0] * vol[6];
449                                                                 paint->sample[7] += sample[1] * vol[7];
450                                                                 indexfrac += indexfracstep;
451                                                                 fetchsampleframe += 2 * (indexfrac >> 16);
452                                                                 indexfrac &= 0xFFFF;
453                                                         }
454                                                 }
455                                                 else
456                                                 {
457                                                         // stereo mixing
458                                                         for (i = 0;i < count;i++, paint++)
459                                                         {
460                                                                 lerp[1] = indexfrac * (1.0f / 65536.0f);
461                                                                 lerp[0] = 1.0f - lerp[1];
462                                                                 sample[0] = fetchsampleframe[0] * lerp[0] + fetchsampleframe[2] * lerp[1];
463                                                                 sample[1] = fetchsampleframe[1] * lerp[0] + fetchsampleframe[3] * lerp[1];
464                                                                 paint->sample[0] += sample[0] * vol[0];
465                                                                 paint->sample[1] += sample[1] * vol[1];
466                                                                 indexfrac += indexfracstep;
467                                                                 fetchsampleframe += 2 * (indexfrac >> 16);
468                                                                 indexfrac &= 0xFFFF;
469                                                         }
470                                                 }
471                                         }
472                                         else if (sfx->format.channels == 1)
473                                         {
474                                                 // most sounds are mono
475 #if SND_LISTENERS != 8
476 #error the following code only supports up to 8 channels, update it
477 #endif
478                                                 if (snd_speakerlayout.channels > 2)
479                                                 {
480                                                         // surround mixing
481                                                         for (i = 0;i < count;i++, paint++)
482                                                         {
483                                                                 lerp[1] = indexfrac * (1.0f / 65536.0f);
484                                                                 lerp[0] = 1.0f - lerp[1];
485                                                                 sample[0] = fetchsampleframe[0] * lerp[0] + fetchsampleframe[1] * lerp[1];
486                                                                 paint->sample[0] += sample[0] * vol[0];
487                                                                 paint->sample[1] += sample[0] * vol[1];
488                                                                 paint->sample[2] += sample[0] * vol[2];
489                                                                 paint->sample[3] += sample[0] * vol[3];
490                                                                 paint->sample[4] += sample[0] * vol[4];
491                                                                 paint->sample[5] += sample[0] * vol[5];
492                                                                 paint->sample[6] += sample[0] * vol[6];
493                                                                 paint->sample[7] += sample[0] * vol[7];
494                                                                 indexfrac += indexfracstep;
495                                                                 fetchsampleframe += (indexfrac >> 16);
496                                                                 indexfrac &= 0xFFFF;
497                                                         }
498                                                 }
499                                                 else
500                                                 {
501                                                         // stereo mixing
502                                                         for (i = 0;i < count;i++, paint++)
503                                                         {
504                                                                 lerp[1] = indexfrac * (1.0f / 65536.0f);
505                                                                 lerp[0] = 1.0f - lerp[1];
506                                                                 sample[0] = fetchsampleframe[0] * lerp[0] + fetchsampleframe[1] * lerp[1];
507                                                                 paint->sample[0] += sample[0] * vol[0];
508                                                                 paint->sample[1] += sample[0] * vol[1];
509                                                                 indexfrac += indexfracstep;
510                                                                 fetchsampleframe += (indexfrac >> 16);
511                                                                 indexfrac &= 0xFFFF;
512                                                         }
513                                                 }
514                                         }
515                                 }
516                         }
517                         ch->position = posd;
518                         if (!looping && istartframe == totallength)
519                                 S_StopChannel(ch - channels, false, false);
520                 }
521
522                 S_SoftClipPaintBuffer(paintbuffer, totalmixframes, snd_renderbuffer->format.width, snd_renderbuffer->format.channels);
523
524                 if (!snd_usethreadedmixing)
525                         S_CaptureAVISound(paintbuffer, totalmixframes);
526
527                 S_ConvertPaintBuffer(paintbuffer, outbytes, totalmixframes, snd_renderbuffer->format.width, snd_renderbuffer->format.channels);
528
529                 // advance the output pointer
530                 outbytes += totalmixframes * snd_renderbuffer->format.width * snd_renderbuffer->format.channels;
531                 bufferframes -= totalmixframes;
532         }
533 }