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
  27
  28 extern void SCR_CaptureVideo_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length);
  29 static void S_CaptureAVISound(size_t length)
  30 {
  31         if (!cls.capturevideo.active)
  32                 return;
  33
  34         SCR_CaptureVideo_SoundFrame(paintbuffer, length);
  35 }
  36
  37 static void S_ConvertPaintBuffer(const portable_sampleframe_t *painted_ptr, void *rb_ptr, int nbframes, int width, int channels)
  38 {
  39         int i, val;
  40         if (width == 2)  // 16bit
  41         {
  42                 short *snd_out = (short*)rb_ptr;
  43                 if (channels == 8)  // 7.1 surround
  44                 {
  45                         for (i = 0;i < nbframes;i++, painted_ptr++)
  46                         {
  47                                 *snd_out++ = bound(-32768, painted_ptr->sample[0], 32767);
  48                                 *snd_out++ = bound(-32768, painted_ptr->sample[1], 32767);
  49                                 *snd_out++ = bound(-32768, painted_ptr->sample[2], 32767);
  50                                 *snd_out++ = bound(-32768, painted_ptr->sample[3], 32767);
  51                                 *snd_out++ = bound(-32768, painted_ptr->sample[4], 32767);
  52                                 *snd_out++ = bound(-32768, painted_ptr->sample[5], 32767);
  53                                 *snd_out++ = bound(-32768, painted_ptr->sample[6], 32767);
  54                                 *snd_out++ = bound(-32768, painted_ptr->sample[7], 32767);
  55                         }
  56                 }
  57                 else if (channels == 6)  // 5.1 surround
  58                 {
  59                         for (i = 0; i < nbframes; i++, painted_ptr++)
  60                         {
  61                                 *snd_out++ = bound(-32768, painted_ptr->sample[0], 32767);
  62                                 *snd_out++ = bound(-32768, painted_ptr->sample[1], 32767);
  63                                 *snd_out++ = bound(-32768, painted_ptr->sample[2], 32767);
  64                                 *snd_out++ = bound(-32768, painted_ptr->sample[3], 32767);
  65                                 *snd_out++ = bound(-32768, painted_ptr->sample[4], 32767);
  66                                 *snd_out++ = bound(-32768, painted_ptr->sample[5], 32767);
  67                         }
  68                 }
  69                 else if (channels == 4)  // 4.0 surround
  70                 {
  71                         for (i = 0; i < nbframes; i++, painted_ptr++)
  72                         {
  73                                 *snd_out++ = bound(-32768, painted_ptr->sample[0], 32767);
  74                                 *snd_out++ = bound(-32768, painted_ptr->sample[1], 32767);
  75                                 *snd_out++ = bound(-32768, painted_ptr->sample[2], 32767);
  76                                 *snd_out++ = bound(-32768, painted_ptr->sample[3], 32767);
  77                         }
  78                 }
  79                 else if (channels == 2)  // 2.0 stereo
  80                 {
  81                         for (i = 0; i < nbframes; i++, painted_ptr++)
  82                         {
  83                                 *snd_out++ = bound(-32768, painted_ptr->sample[0], 32767);
  84                                 *snd_out++ = bound(-32768, painted_ptr->sample[1], 32767);
  85                         }
  86                 }
  87                 else if (channels == 1)  // 1.0 mono
  88                 {
  89                         for (i = 0; i < nbframes; i++, painted_ptr++)
  90                         {
  91                                 val = (painted_ptr->sample[0] + painted_ptr->sample[1]) >> 1;
  92                                 *snd_out++ = bound(-32768, val, 32767);
  93                         }
  94                 }
  95         }
  96         else  // 8bit
  97         {
  98                 unsigned char *snd_out = (unsigned char*)rb_ptr;
  99                 if (channels == 8)  // 7.1 surround
 100                 {
 101                         for (i = 0; i < nbframes; i++, painted_ptr++)
 102                         {
 103                                 val = (painted_ptr->sample[0] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 104                                 val = (painted_ptr->sample[1] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 105                                 val = (painted_ptr->sample[2] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 106                                 val = (painted_ptr->sample[3] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 107                                 val = (painted_ptr->sample[4] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 108                                 val = (painted_ptr->sample[5] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 109                                 val = (painted_ptr->sample[6] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 110                                 val = (painted_ptr->sample[7] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 111                         }
 112                 }
 113                 else if (channels == 6)  // 5.1 surround
 114                 {
 115                         for (i = 0; i < nbframes; i++, painted_ptr++)
 116                         {
 117                                 val = (painted_ptr->sample[0] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 118                                 val = (painted_ptr->sample[1] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 119                                 val = (painted_ptr->sample[2] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 120                                 val = (painted_ptr->sample[3] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 121                                 val = (painted_ptr->sample[4] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 122                                 val = (painted_ptr->sample[5] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 123                         }
 124                 }
 125                 else if (channels == 4)  // 4.0 surround
 126                 {
 127                         for (i = 0; i < nbframes; i++, painted_ptr++)
 128                         {
 129                                 val = (painted_ptr->sample[0] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 130                                 val = (painted_ptr->sample[1] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 131                                 val = (painted_ptr->sample[2] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 132                                 val = (painted_ptr->sample[3] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 133                         }
 134                 }
 135                 else if (channels == 2)  // 2.0 stereo
 136                 {
 137                         for (i = 0; i < nbframes; i++, painted_ptr++)
 138                         {
 139                                 val = (painted_ptr->sample[0] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 140                                 val = (painted_ptr->sample[1] >> 8) + 128; *snd_out++ = bound(0, val, 255);
 141                         }
 142                 }
 143                 else if (channels == 1)  // 1.0 mono
 144                 {
 145                         for (i = 0;i < nbframes;i++, painted_ptr++)
 146                         {
 147                                 val = ((painted_ptr->sample[0] + painted_ptr->sample[1]) >> 9) + 128;
 148                                 *snd_out++ = bound(0, val, 255);
 149                         }
 150                 }
 151         }
 152 }
 153
 154
 155 /*
 156 ===============================================================================
 157
 158 CHANNEL MIXING
 159
 160 ===============================================================================
 161 */
 162
 163 static qboolean SND_PaintChannel (channel_t *ch, portable_sampleframe_t *paint, unsigned int count)
 164 {
 165         int snd_vol, vol[SND_LISTENERS];
 166         const snd_buffer_t *sb;
 167         unsigned int i, sb_offset;
 168
 169         // If this channel manages its own volume
 170         if (ch->flags & CHANNELFLAG_FULLVOLUME)
 171                 snd_vol = 256;
 172         else
 173                 snd_vol = (int)(volume.value * 256);
 174
 175         // calculate mixing volumes based on channel volumes and volume cvar
 176         // also limit the volumes to values that won't clip
 177         for (i = 0;i < SND_LISTENERS;i++)
 178         {
 179                 vol[i] = ch->listener_volume[i] * snd_vol;
 180                 vol[i] = bound(0, vol[i], 65536);
 181         }
 182
 183         // if volumes are all zero, just return
 184         for (i = 0;i < SND_LISTENERS;i++)
 185                 if (vol[i])
 186                         break;
 187         if (i == SND_LISTENERS)
 188                 return false;
 189
 190         sb_offset = ch->pos;
 191         sb = ch->sfx->fetcher->getsb (ch->sfx->fetcher_data, &ch->fetcher_data, &sb_offset, count);
 192         if (sb == NULL)
 193         {
 194                 Con_DPrintf("SND_PaintChannel: ERROR: can't get sound buffer from sfx \"%s\"\n",
 195                                         ch->sfx->name); // , count); // or add this? FIXME
 196                 return false;
 197         }
 198         else
 199         {
 200 #if SND_LISTENERS != 8
 201 #               error the following code only supports up to 8 channels, update it
 202 #endif
 203                 if (sb->format.width == 1)
 204                 {
 205                         const signed char *samples = (signed char*)sb->samples + (ch->pos - sb_offset) * sb->format.channels;
 206
 207                         // Stereo sound support
 208                         if (sb->format.channels == 2)
 209                         {
 210                                 if (vol[6] + vol[7] > 0)
 211                                 {
 212                                         for (i = 0;i < count;i++)
 213                                         {
 214                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 8;
 215                                                 paint[i].sample[1] += (samples[1] * vol[1]) >> 8;
 216                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 8;
 217                                                 paint[i].sample[3] += (samples[1] * vol[3]) >> 8;
 218                                                 paint[i].sample[4] += ((samples[0] + samples[1]) * vol[4]) >> 9;
 219                                                 paint[i].sample[5] += ((samples[0] + samples[1]) * vol[5]) >> 9;
 220                                                 paint[i].sample[6] += (samples[0] * vol[6]) >> 8;
 221                                                 paint[i].sample[7] += (samples[1] * vol[7]) >> 8;
 222                                                 samples += 2;
 223                                         }
 224                                 }
 225                                 else if (vol[4] + vol[5] > 0)
 226                                 {
 227                                         for (i = 0;i < count;i++)
 228                                         {
 229                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 8;
 230                                                 paint[i].sample[1] += (samples[1] * vol[1]) >> 8;
 231                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 8;
 232                                                 paint[i].sample[3] += (samples[1] * vol[3]) >> 8;
 233                                                 paint[i].sample[4] += ((samples[0] + samples[1]) * vol[4]) >> 9;
 234                                                 paint[i].sample[5] += ((samples[0] + samples[1]) * vol[5]) >> 9;
 235                                                 samples += 2;
 236                                         }
 237                                 }
 238                                 else if (vol[2] + vol[3] > 0)
 239                                 {
 240                                         for (i = 0;i < count;i++)
 241                                         {
 242                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 8;
 243                                                 paint[i].sample[1] += (samples[1] * vol[1]) >> 8;
 244                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 8;
 245                                                 paint[i].sample[3] += (samples[1] * vol[3]) >> 8;
 246                                                 samples += 2;
 247                                         }
 248                                 }
 249                                 else if (vol[0] + vol[1] > 0)
 250                                 {
 251                                         for (i = 0;i < count;i++)
 252                                         {
 253                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 8;
 254                                                 paint[i].sample[1] += (samples[1] * vol[1]) >> 8;
 255                                                 samples += 2;
 256                                         }
 257                                 }
 258                         }
 259                         else if (sb->format.channels == 1)
 260                         {
 261                                 if (vol[6] + vol[7] > 0)
 262                                 {
 263                                         for (i = 0;i < count;i++)
 264                                         {
 265                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 8;
 266                                                 paint[i].sample[1] += (samples[0] * vol[1]) >> 8;
 267                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 8;
 268                                                 paint[i].sample[3] += (samples[0] * vol[3]) >> 8;
 269                                                 paint[i].sample[4] += (samples[0] * vol[4]) >> 8;
 270                                                 paint[i].sample[5] += (samples[0] * vol[5]) >> 8;
 271                                                 paint[i].sample[6] += (samples[0] * vol[6]) >> 8;
 272                                                 paint[i].sample[7] += (samples[0] * vol[7]) >> 8;
 273                                                 samples += 1;
 274                                         }
 275                                 }
 276                                 else if (vol[4] + vol[5] > 0)
 277                                 {
 278                                         for (i = 0;i < count;i++)
 279                                         {
 280                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 8;
 281                                                 paint[i].sample[1] += (samples[0] * vol[1]) >> 8;
 282                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 8;
 283                                                 paint[i].sample[3] += (samples[0] * vol[3]) >> 8;
 284                                                 paint[i].sample[4] += (samples[0] * vol[4]) >> 8;
 285                                                 paint[i].sample[5] += (samples[0] * vol[5]) >> 8;
 286                                                 samples += 1;
 287                                         }
 288                                 }
 289                                 else if (vol[2] + vol[3] > 0)
 290                                 {
 291                                         for (i = 0;i < count;i++)
 292                                         {
 293                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 8;
 294                                                 paint[i].sample[1] += (samples[0] * vol[1]) >> 8;
 295                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 8;
 296                                                 paint[i].sample[3] += (samples[0] * vol[3]) >> 8;
 297                                                 samples += 1;
 298                                         }
 299                                 }
 300                                 else if (vol[0] + vol[1] > 0)
 301                                 {
 302                                         for (i = 0;i < count;i++)
 303                                         {
 304                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 8;
 305                                                 paint[i].sample[1] += (samples[0] * vol[1]) >> 8;
 306                                                 samples += 1;
 307                                         }
 308                                 }
 309                         }
 310                         else
 311                                 return false; // unsupported number of channels in sound
 312                 }
 313                 else if (sb->format.width == 2)
 314                 {
 315                         const signed short *samples = (signed short*)sb->samples + (ch->pos - sb_offset) * sb->format.channels;
 316
 317                         // Stereo sound support
 318                         if (sb->format.channels == 2)
 319                         {
 320                                 if (vol[6] + vol[7] > 0)
 321                                 {
 322                                         for (i = 0;i < count;i++)
 323                                         {
 324                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 16;
 325                                                 paint[i].sample[1] += (samples[1] * vol[1]) >> 16;
 326                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 16;
 327                                                 paint[i].sample[3] += (samples[1] * vol[3]) >> 16;
 328                                                 paint[i].sample[4] += ((samples[0] + samples[1]) * vol[4]) >> 17;
 329                                                 paint[i].sample[5] += ((samples[0] + samples[1]) * vol[5]) >> 17;
 330                                                 paint[i].sample[6] += (samples[0] * vol[6]) >> 16;
 331                                                 paint[i].sample[7] += (samples[1] * vol[7]) >> 16;
 332                                                 samples += 2;
 333                                         }
 334                                 }
 335                                 else if (vol[4] + vol[5] > 0)
 336                                 {
 337                                         for (i = 0;i < count;i++)
 338                                         {
 339                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 16;
 340                                                 paint[i].sample[1] += (samples[1] * vol[1]) >> 16;
 341                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 16;
 342                                                 paint[i].sample[3] += (samples[1] * vol[3]) >> 16;
 343                                                 paint[i].sample[4] += ((samples[0] + samples[1]) * vol[4]) >> 17;
 344                                                 paint[i].sample[5] += ((samples[0] + samples[1]) * vol[5]) >> 17;
 345                                                 samples += 2;
 346                                         }
 347                                 }
 348                                 else if (vol[2] + vol[3] > 0)
 349                                 {
 350                                         for (i = 0;i < count;i++)
 351                                         {
 352                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 16;
 353                                                 paint[i].sample[1] += (samples[1] * vol[1]) >> 16;
 354                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 16;
 355                                                 paint[i].sample[3] += (samples[1] * vol[3]) >> 16;
 356                                                 samples += 2;
 357                                         }
 358                                 }
 359                                 else if (vol[0] + vol[1] > 0)
 360                                 {
 361                                         for (i = 0;i < count;i++)
 362                                         {
 363                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 16;
 364                                                 paint[i].sample[1] += (samples[1] * vol[1]) >> 16;
 365                                                 samples += 2;
 366                                         }
 367                                 }
 368                         }
 369                         else if (sb->format.channels == 1)
 370                         {
 371                                 if (vol[6] + vol[7] > 0)
 372                                 {
 373                                         for (i = 0;i < count;i++)
 374                                         {
 375                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 16;
 376                                                 paint[i].sample[1] += (samples[0] * vol[1]) >> 16;
 377                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 16;
 378                                                 paint[i].sample[3] += (samples[0] * vol[3]) >> 16;
 379                                                 paint[i].sample[4] += (samples[0] * vol[4]) >> 16;
 380                                                 paint[i].sample[5] += (samples[0] * vol[5]) >> 16;
 381                                                 paint[i].sample[6] += (samples[0] * vol[6]) >> 16;
 382                                                 paint[i].sample[7] += (samples[0] * vol[7]) >> 16;
 383                                                 samples += 1;
 384                                         }
 385                                 }
 386                                 else if (vol[4] + vol[5] > 0)
 387                                 {
 388                                         for (i = 0;i < count;i++)
 389                                         {
 390                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 16;
 391                                                 paint[i].sample[1] += (samples[0] * vol[1]) >> 16;
 392                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 16;
 393                                                 paint[i].sample[3] += (samples[0] * vol[3]) >> 16;
 394                                                 paint[i].sample[4] += (samples[0] * vol[4]) >> 16;
 395                                                 paint[i].sample[5] += (samples[0] * vol[5]) >> 16;
 396                                                 samples += 1;
 397                                         }
 398                                 }
 399                                 else if (vol[2] + vol[3] > 0)
 400                                 {
 401                                         for (i = 0;i < count;i++)
 402                                         {
 403                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 16;
 404                                                 paint[i].sample[1] += (samples[0] * vol[1]) >> 16;
 405                                                 paint[i].sample[2] += (samples[0] * vol[2]) >> 16;
 406                                                 paint[i].sample[3] += (samples[0] * vol[3]) >> 16;
 407                                                 samples += 1;
 408                                         }
 409                                 }
 410                                 else if (vol[0] + vol[1] > 0)
 411                                 {
 412                                         for (i = 0;i < count;i++)
 413                                         {
 414                                                 paint[i].sample[0] += (samples[0] * vol[0]) >> 16;
 415                                                 paint[i].sample[1] += (samples[0] * vol[1]) >> 16;
 416                                                 samples += 1;
 417                                         }
 418                                 }
 419                         }
 420                         else
 421                                 return false; // unsupported number of channels in sound
 422                 }
 423         }
 424         return true;
 425 }
 426
 427 void S_MixToBuffer(void *stream, unsigned int bufferframes)
 428 {
 429         unsigned int i;
 430         channel_t *ch;
 431         unsigned int frames;
 432         unsigned char *outbytes = (unsigned char *) stream;
 433
 434         // mix as many times as needed to fill the requested buffer
 435         while (bufferframes)
 436         {
 437                 // limit to the size of the paint buffer
 438                 frames = min(bufferframes, PAINTBUFFER_SIZE);
 439
 440                 // clear the paint buffer
 441                 memset (paintbuffer, 0, frames * sizeof (paintbuffer[0]));
 442
 443                 // paint in the channels.
 444                 // channels with zero volumes still advance in time but don't paint.
 445                 ch = channels;
 446                 for (i = 0; i < total_channels ; i++, ch++)
 447                 {
 448                         sfx_t *sfx;
 449                         unsigned int ltime;
 450                         unsigned int count;
 451
 452                         sfx = ch->sfx;
 453                         if (sfx == NULL)
 454                                 continue;
 455                         if (!S_LoadSound (sfx, true))
 456                                 continue;
 457                         if (ch->flags & CHANNELFLAG_PAUSED)
 458                                 continue;
 459
 460                         ltime = 0;
 461                         if (ch->pos < 0)
 462                         {
 463                                 count = -ch->pos;
 464                                 count = min(count, frames - ltime);
 465                                 ch->pos += count;
 466                                 ltime += count;
 467                         }
 468
 469                         while (ltime < frames)
 470                         {
 471                                 // paint up to end of buffer or of input, whichever is lower
 472                                 count = sfx->total_length - ch->pos;
 473                                 count = bound(0, count, frames - ltime);
 474                                 if (count)
 475                                 {
 476                                         SND_PaintChannel (ch, paintbuffer + ltime, count);
 477                                         ch->pos += count;
 478                                         ltime += count;
 479                                 }
 480
 481                                 // if at end of sfx, loop or stop the channel
 482                                 if (ch->pos >= (int)sfx->total_length)
 483                                 {
 484                                         if (sfx->loopstart < sfx->total_length)
 485                                                 ch->pos = sfx->loopstart;
 486                                         else if (ch->flags & CHANNELFLAG_FORCELOOP)
 487                                                 ch->pos = 0;
 488                                         else
 489                                         {
 490                                                 S_StopChannel (ch - channels, false);
 491                                                 break;
 492                                         }
 493                                 }
 494                         }
 495                 }
 496
 497                 if (!snd_usethreadedmixing)
 498                         S_CaptureAVISound(frames);
 499
 500                 S_ConvertPaintBuffer(paintbuffer, outbytes, frames, snd_renderbuffer->format.width, snd_renderbuffer->format.channels);
 501
 502                 // advance the output pointer
 503                 outbytes += frames * snd_renderbuffer->format.width * snd_renderbuffer->format.channels;
 504                 bufferframes -= frames;
 505         }
 506 }