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