Alc/mixer.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <math.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <assert.h>
  28
  29 #include "alMain.h"
  30 #include "AL/al.h"
  31 #include "AL/alc.h"
  32 #include "alSource.h"
  33 #include "alBuffer.h"
  34 #include "alListener.h"
  35 #include "alAuxEffectSlot.h"
  36 #include "alu.h"
  37
  38 #include "mixer_defs.h"
  39
  40
  41 static_assert((INT_MAX>>FRACTIONBITS)/MAX_PITCH > BUFFERSIZE,
  42               "MAX_PITCH and/or BUFFERSIZE are too large for FRACTIONBITS!");
  43
  44 extern inline void InitiatePositionArrays(ALuint frac, ALuint increment, ALuint *restrict frac_arr, ALuint *restrict pos_arr, ALuint size);
  45
  46 alignas(16) union ResamplerCoeffs ResampleCoeffs;
  47
  48
  49 enum Resampler {
  50     PointResampler,
  51     LinearResampler,
  52     FIR4Resampler,
  53     FIR8Resampler,
  54     BSincResampler,
  55
  56     ResamplerDefault = LinearResampler
  57 };
  58
  59 /* FIR8 requires 3 extra samples before the current position, and 4 after. */
  60 static_assert(MAX_PRE_SAMPLES >= 3, "MAX_PRE_SAMPLES must be at least 3!");
  61 static_assert(MAX_POST_SAMPLES >= 4, "MAX_POST_SAMPLES must be at least 4!");
  62
  63
  64 static MixerFunc MixSamples = Mix_C;
  65 static HrtfMixerFunc MixHrtfSamples = MixHrtf_C;
  66 static ResamplerFunc ResampleSamples = Resample_point32_C;
  67
  68 MixerFunc SelectMixer(void)
  69 {
  70 #ifdef HAVE_SSE
  71     if((CPUCapFlags&CPU_CAP_SSE))
  72         return Mix_SSE;
  73 #endif
  74 #ifdef HAVE_NEON
  75     if((CPUCapFlags&CPU_CAP_NEON))
  76         return Mix_Neon;
  77 #endif
  78
  79     return Mix_C;
  80 }
  81
  82 RowMixerFunc SelectRowMixer(void)
  83 {
  84 #ifdef HAVE_SSE
  85     if((CPUCapFlags&CPU_CAP_SSE))
  86         return MixRow_SSE;
  87 #endif
  88 #ifdef HAVE_NEON
  89     if((CPUCapFlags&CPU_CAP_NEON))
  90         return MixRow_Neon;
  91 #endif
  92     return MixRow_C;
  93 }
  94
  95 static inline HrtfMixerFunc SelectHrtfMixer(void)
  96 {
  97 #ifdef HAVE_SSE
  98     if((CPUCapFlags&CPU_CAP_SSE))
  99         return MixHrtf_SSE;
 100 #endif
 101 #ifdef HAVE_NEON
 102     if((CPUCapFlags&CPU_CAP_NEON))
 103         return MixHrtf_Neon;
 104 #endif
 105
 106     return MixHrtf_C;
 107 }
 108
 109 static inline ResamplerFunc SelectResampler(enum Resampler resampler)
 110 {
 111     switch(resampler)
 112     {
 113         case PointResampler:
 114             return Resample_point32_C;
 115         case LinearResampler:
 116 #ifdef HAVE_SSE4_1
 117             if((CPUCapFlags&CPU_CAP_SSE4_1))
 118                 return Resample_lerp32_SSE41;
 119 #endif
 120 #ifdef HAVE_SSE2
 121             if((CPUCapFlags&CPU_CAP_SSE2))
 122                 return Resample_lerp32_SSE2;
 123 #endif
 124             return Resample_lerp32_C;
 125         case FIR4Resampler:
 126 #ifdef HAVE_SSE4_1
 127             if((CPUCapFlags&CPU_CAP_SSE4_1))
 128                 return Resample_fir4_32_SSE41;
 129 #endif
 130 #ifdef HAVE_SSE3
 131             if((CPUCapFlags&CPU_CAP_SSE3))
 132                 return Resample_fir4_32_SSE3;
 133 #endif
 134             return Resample_fir4_32_C;
 135         case FIR8Resampler:
 136 #ifdef HAVE_SSE4_1
 137             if((CPUCapFlags&CPU_CAP_SSE4_1))
 138                 return Resample_fir8_32_SSE41;
 139 #endif
 140 #ifdef HAVE_SSE3
 141             if((CPUCapFlags&CPU_CAP_SSE3))
 142                 return Resample_fir8_32_SSE3;
 143 #endif
 144             return Resample_fir8_32_C;
 145         case BSincResampler:
 146 #ifdef HAVE_SSE
 147             if((CPUCapFlags&CPU_CAP_SSE))
 148                 return Resample_bsinc32_SSE;
 149 #endif
 150             return Resample_bsinc32_C;
 151     }
 152
 153     return Resample_point32_C;
 154 }
 155
 156
 157 /* The sinc resampler makes use of a Kaiser window to limit the needed sample
 158  * points to 4 and 8, respectively.
 159  */
 160
 161 #ifndef M_PI
 162 #define M_PI                         (3.14159265358979323846)
 163 #endif
 164 static inline double Sinc(double x)
 165 {
 166     if(x == 0.0) return 1.0;
 167     return sin(x*M_PI) / (x*M_PI);
 168 }
 169
 170 /* The zero-order modified Bessel function of the first kind, used for the
 171  * Kaiser window.
 172  *
 173  *   I_0(x) = sum_{k=0}^inf (1 / k!)^2 (x / 2)^(2 k)
 174  *          = sum_{k=0}^inf ((x / 2)^k / k!)^2
 175  */
 176 static double BesselI_0(double x)
 177 {
 178     double term, sum, x2, y, last_sum;
 179     int k;
 180
 181     /* Start at k=1 since k=0 is trivial. */
 182     term = 1.0;
 183     sum = 1.0;
 184     x2 = x / 2.0;
 185     k = 1;
 186
 187     /* Let the integration converge until the term of the sum is no longer
 188      * significant.
 189      */
 190     do {
 191         y = x2 / k;
 192         k ++;
 193         last_sum = sum;
 194         term *= y * y;
 195         sum += term;
 196     } while(sum != last_sum);
 197     return sum;
 198 }
 199
 200 /* Calculate a Kaiser window from the given beta value and a normalized k
 201  * [-1, 1].
 202  *
 203  *   w(k) = { I_0(B sqrt(1 - k^2)) / I_0(B),  -1 <= k <= 1
 204  *          { 0,                              elsewhere.
 205  *
 206  * Where k can be calculated as:
 207  *
 208  *   k = i / l,         where -l <= i <= l.
 209  *
 210  * or:
 211  *
 212  *   k = 2 i / M - 1,   where 0 <= i <= M.
 213  */
 214 static inline double Kaiser(double b, double k)
 215 {
 216     if(k <= -1.0 || k >= 1.0) return 0.0;
 217     return BesselI_0(b * sqrt(1.0 - (k*k))) / BesselI_0(b);
 218 }
 219
 220 static inline double CalcKaiserBeta(double rejection)
 221 {
 222     if(rejection > 50.0)
 223         return 0.1102 * (rejection - 8.7);
 224     if(rejection >= 21.0)
 225         return (0.5842 * pow(rejection - 21.0, 0.4)) +
 226                (0.07886 * (rejection - 21.0));
 227     return 0.0;
 228 }
 229
 230 static float SincKaiser(double r, double x)
 231 {
 232     /* Limit rippling to -60dB. */
 233     return (float)(Kaiser(CalcKaiserBeta(60.0), x / r) * Sinc(x));
 234 }
 235
 236
 237 void aluInitMixer(void)
 238 {
 239     enum Resampler resampler = ResamplerDefault;
 240     const char *str;
 241     ALuint i;
 242
 243     if(ConfigValueStr(NULL, NULL, "resampler", &str))
 244     {
 245         if(strcasecmp(str, "point") == 0 || strcasecmp(str, "none") == 0)
 246             resampler = PointResampler;
 247         else if(strcasecmp(str, "linear") == 0)
 248             resampler = LinearResampler;
 249         else if(strcasecmp(str, "sinc4") == 0)
 250             resampler = FIR4Resampler;
 251         else if(strcasecmp(str, "sinc8") == 0)
 252             resampler = FIR8Resampler;
 253         else if(strcasecmp(str, "bsinc") == 0)
 254             resampler = BSincResampler;
 255         else if(strcasecmp(str, "cubic") == 0)
 256         {
 257             WARN("Resampler option \"cubic\" is deprecated, using sinc4\n");
 258             resampler = FIR4Resampler;
 259         }
 260         else
 261         {
 262             char *end;
 263             long n = strtol(str, &end, 0);
 264             if(*end == '\0' && (n == PointResampler || n == LinearResampler || n == FIR4Resampler))
 265                 resampler = n;
 266             else
 267                 WARN("Invalid resampler: %s\n", str);
 268         }
 269     }
 270
 271     if(resampler == FIR8Resampler)
 272         for(i = 0;i < FRACTIONONE;i++)
 273         {
 274             ALdouble mu = (ALdouble)i / FRACTIONONE;
 275             ResampleCoeffs.FIR8[i][0] = SincKaiser(4.0, mu - -3.0);
 276             ResampleCoeffs.FIR8[i][1] = SincKaiser(4.0, mu - -2.0);
 277             ResampleCoeffs.FIR8[i][2] = SincKaiser(4.0, mu - -1.0);
 278             ResampleCoeffs.FIR8[i][3] = SincKaiser(4.0, mu -  0.0);
 279             ResampleCoeffs.FIR8[i][4] = SincKaiser(4.0, mu -  1.0);
 280             ResampleCoeffs.FIR8[i][5] = SincKaiser(4.0, mu -  2.0);
 281             ResampleCoeffs.FIR8[i][6] = SincKaiser(4.0, mu -  3.0);
 282             ResampleCoeffs.FIR8[i][7] = SincKaiser(4.0, mu -  4.0);
 283         }
 284     else if(resampler == FIR4Resampler)
 285         for(i = 0;i < FRACTIONONE;i++)
 286         {
 287             ALdouble mu = (ALdouble)i / FRACTIONONE;
 288             ResampleCoeffs.FIR4[i][0] = SincKaiser(2.0, mu - -1.0);
 289             ResampleCoeffs.FIR4[i][1] = SincKaiser(2.0, mu -  0.0);
 290             ResampleCoeffs.FIR4[i][2] = SincKaiser(2.0, mu -  1.0);
 291             ResampleCoeffs.FIR4[i][3] = SincKaiser(2.0, mu -  2.0);
 292         }
 293
 294     MixHrtfSamples = SelectHrtfMixer();
 295     MixSamples = SelectMixer();
 296     ResampleSamples = SelectResampler(resampler);
 297 }
 298
 299
 300 static inline ALfloat Sample_ALbyte(ALbyte val)
 301 { return val * (1.0f/127.0f); }
 302
 303 static inline ALfloat Sample_ALshort(ALshort val)
 304 { return val * (1.0f/32767.0f); }
 305
 306 static inline ALfloat Sample_ALfloat(ALfloat val)
 307 { return val; }
 308
 309 #define DECL_TEMPLATE(T)                                                      \
 310 static inline void Load_##T(ALfloat *dst, const T *src, ALuint srcstep, ALuint samples)\
 311 {                                                                             \
 312     ALuint i;                                                                 \
 313     for(i = 0;i < samples;i++)                                                \
 314         dst[i] = Sample_##T(src[i*srcstep]);                                  \
 315 }
 316
 317 DECL_TEMPLATE(ALbyte)
 318 DECL_TEMPLATE(ALshort)
 319 DECL_TEMPLATE(ALfloat)
 320
 321 #undef DECL_TEMPLATE
 322
 323 static void LoadSamples(ALfloat *dst, const ALvoid *src, ALuint srcstep, enum FmtType srctype, ALuint samples)
 324 {
 325     switch(srctype)
 326     {
 327         case FmtByte:
 328             Load_ALbyte(dst, src, srcstep, samples);
 329             break;
 330         case FmtShort:
 331             Load_ALshort(dst, src, srcstep, samples);
 332             break;
 333         case FmtFloat:
 334             Load_ALfloat(dst, src, srcstep, samples);
 335             break;
 336     }
 337 }
 338
 339 static inline void SilenceSamples(ALfloat *dst, ALuint samples)
 340 {
 341     ALuint i;
 342     for(i = 0;i < samples;i++)
 343         dst[i] = 0.0f;
 344 }
 345
 346
 347 static const ALfloat *DoFilters(ALfilterState *lpfilter, ALfilterState *hpfilter,
 348                                 ALfloat *restrict dst, const ALfloat *restrict src,
 349                                 ALuint numsamples, enum ActiveFilters type)
 350 {
 351     ALuint i;
 352     switch(type)
 353     {
 354         case AF_None:
 355             ALfilterState_processPassthru(lpfilter, src, numsamples);
 356             ALfilterState_processPassthru(hpfilter, src, numsamples);
 357             break;
 358
 359         case AF_LowPass:
 360             ALfilterState_process(lpfilter, dst, src, numsamples);
 361             ALfilterState_processPassthru(hpfilter, dst, numsamples);
 362             return dst;
 363         case AF_HighPass:
 364             ALfilterState_processPassthru(lpfilter, src, numsamples);
 365             ALfilterState_process(hpfilter, dst, src, numsamples);
 366             return dst;
 367
 368         case AF_BandPass:
 369             for(i = 0;i < numsamples;)
 370             {
 371                 ALfloat temp[256];
 372                 ALuint todo = minu(256, numsamples-i);
 373
 374                 ALfilterState_process(lpfilter, temp, src+i, todo);
 375                 ALfilterState_process(hpfilter, dst+i, temp, todo);
 376                 i += todo;
 377             }
 378             return dst;
 379     }
 380     return src;
 381 }
 382
 383
 384 ALvoid MixSource(ALvoice *voice, ALsource *Source, ALCdevice *Device, ALuint SamplesToDo)
 385 {
 386     ResamplerFunc Resample;
 387     ALbufferlistitem *BufferListItem;
 388     ALuint DataPosInt, DataPosFrac;
 389     ALboolean Looping;
 390     ALuint increment;
 391     ALenum State;
 392     ALuint OutPos;
 393     ALuint NumChannels;
 394     ALuint SampleSize;
 395     ALint64 DataSize64;
 396     ALuint Counter;
 397     ALuint IrSize;
 398     ALuint chan, send, j;
 399
 400     /* Get source info */
 401     State          = AL_PLAYING; /* Only called while playing. */
 402     BufferListItem = ATOMIC_LOAD(&Source->current_buffer);
 403     DataPosInt     = ATOMIC_LOAD(&Source->position, almemory_order_relaxed);
 404     DataPosFrac    = ATOMIC_LOAD(&Source->position_fraction, almemory_order_relaxed);
 405     Looping        = ATOMIC_LOAD(&Source->looping, almemory_order_relaxed);
 406     NumChannels    = Source->NumChannels;
 407     SampleSize     = Source->SampleSize;
 408     increment      = voice->Step;
 409
 410     IrSize = (Device->Hrtf.Handle ? Device->Hrtf.Handle->irSize : 0);
 411
 412     Resample = ((increment == FRACTIONONE && DataPosFrac == 0) ?
 413                 Resample_copy32_C : ResampleSamples);
 414
 415     Counter = voice->Moving ? SamplesToDo : 0;
 416     OutPos = 0;
 417     do {
 418         ALuint SrcBufferSize, DstBufferSize;
 419
 420         /* Figure out how many buffer samples will be needed */
 421         DataSize64  = SamplesToDo-OutPos;
 422         DataSize64 *= increment;
 423         DataSize64 += DataPosFrac+FRACTIONMASK;
 424         DataSize64 >>= FRACTIONBITS;
 425         DataSize64 += MAX_POST_SAMPLES+MAX_PRE_SAMPLES;
 426
 427         SrcBufferSize = (ALuint)mini64(DataSize64, BUFFERSIZE);
 428
 429         /* Figure out how many samples we can actually mix from this. */
 430         DataSize64  = SrcBufferSize;
 431         DataSize64 -= MAX_POST_SAMPLES+MAX_PRE_SAMPLES;
 432         DataSize64 <<= FRACTIONBITS;
 433         DataSize64 -= DataPosFrac;
 434
 435         DstBufferSize = (ALuint)((DataSize64+(increment-1)) / increment);
 436         DstBufferSize = minu(DstBufferSize, (SamplesToDo-OutPos));
 437
 438         /* Some mixers like having a multiple of 4, so try to give that unless
 439          * this is the last update. */
 440         if(OutPos+DstBufferSize < SamplesToDo)
 441             DstBufferSize &= ~3;
 442
 443         for(chan = 0;chan < NumChannels;chan++)
 444         {
 445             const ALfloat *ResampledData;
 446             ALfloat *SrcData = Device->SourceData;
 447             ALuint SrcDataSize;
 448
 449             /* Load the previous samples into the source data first. */
 450             memcpy(SrcData, voice->PrevSamples[chan], MAX_PRE_SAMPLES*sizeof(ALfloat));
 451             SrcDataSize = MAX_PRE_SAMPLES;
 452
 453             if(Source->SourceType == AL_STATIC)
 454             {
 455                 const ALbuffer *ALBuffer = BufferListItem->buffer;
 456                 const ALubyte *Data = ALBuffer->data;
 457                 ALuint DataSize;
 458                 ALuint pos;
 459
 460                 /* Offset buffer data to current channel */
 461                 Data += chan*SampleSize;
 462
 463                 /* If current pos is beyond the loop range, do not loop */
 464                 if(Looping == AL_FALSE || DataPosInt >= (ALuint)ALBuffer->LoopEnd)
 465                 {
 466                     Looping = AL_FALSE;
 467
 468                     /* Load what's left to play from the source buffer, and
 469                      * clear the rest of the temp buffer */
 470                     pos = DataPosInt;
 471                     DataSize = minu(SrcBufferSize - SrcDataSize, ALBuffer->SampleLen - pos);
 472
 473                     LoadSamples(&SrcData[SrcDataSize], &Data[pos * NumChannels*SampleSize],
 474                                 NumChannels, ALBuffer->FmtType, DataSize);
 475                     SrcDataSize += DataSize;
 476
 477                     SilenceSamples(&SrcData[SrcDataSize], SrcBufferSize - SrcDataSize);
 478                     SrcDataSize += SrcBufferSize - SrcDataSize;
 479                 }
 480                 else
 481                 {
 482                     ALuint LoopStart = ALBuffer->LoopStart;
 483                     ALuint LoopEnd   = ALBuffer->LoopEnd;
 484
 485                     /* Load what's left of this loop iteration, then load
 486                      * repeats of the loop section */
 487                     pos = DataPosInt;
 488                     DataSize = LoopEnd - pos;
 489                     DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
 490
 491                     LoadSamples(&SrcData[SrcDataSize], &Data[pos * NumChannels*SampleSize],
 492                                 NumChannels, ALBuffer->FmtType, DataSize);
 493                     SrcDataSize += DataSize;
 494
 495                     DataSize = LoopEnd-LoopStart;
 496                     while(SrcBufferSize > SrcDataSize)
 497                     {
 498                         DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
 499
 500                         LoadSamples(&SrcData[SrcDataSize], &Data[LoopStart * NumChannels*SampleSize],
 501                                     NumChannels, ALBuffer->FmtType, DataSize);
 502                         SrcDataSize += DataSize;
 503                     }
 504                 }
 505             }
 506             else
 507             {
 508                 /* Crawl the buffer queue to fill in the temp buffer */
 509                 ALbufferlistitem *tmpiter = BufferListItem;
 510                 ALuint pos = DataPosInt;
 511
 512                 while(tmpiter && SrcBufferSize > SrcDataSize)
 513                 {
 514                     const ALbuffer *ALBuffer;
 515                     if((ALBuffer=tmpiter->buffer) != NULL)
 516                     {
 517                         const ALubyte *Data = ALBuffer->data;
 518                         ALuint DataSize = ALBuffer->SampleLen;
 519
 520                         /* Skip the data already played */
 521                         if(DataSize <= pos)
 522                             pos -= DataSize;
 523                         else
 524                         {
 525                             Data += (pos*NumChannels + chan)*SampleSize;
 526                             DataSize -= pos;
 527                             pos -= pos;
 528
 529                             DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
 530                             LoadSamples(&SrcData[SrcDataSize], Data, NumChannels,
 531                                         ALBuffer->FmtType, DataSize);
 532                             SrcDataSize += DataSize;
 533                         }
 534                     }
 535                     tmpiter = tmpiter->next;
 536                     if(!tmpiter && Looping)
 537                         tmpiter = ATOMIC_LOAD(&Source->queue);
 538                     else if(!tmpiter)
 539                     {
 540                         SilenceSamples(&SrcData[SrcDataSize], SrcBufferSize - SrcDataSize);
 541                         SrcDataSize += SrcBufferSize - SrcDataSize;
 542                     }
 543                 }
 544             }
 545
 546             /* Store the last source samples used for next time. */
 547             memcpy(voice->PrevSamples[chan],
 548                 &SrcData[(increment*DstBufferSize + DataPosFrac)>>FRACTIONBITS],
 549                 MAX_PRE_SAMPLES*sizeof(ALfloat)
 550             );
 551
 552             /* Now resample, then filter and mix to the appropriate outputs. */
 553             ResampledData = Resample(&voice->SincState,
 554                 &SrcData[MAX_PRE_SAMPLES], DataPosFrac, increment,
 555                 Device->ResampledData, DstBufferSize
 556             );
 557             {
 558                 DirectParams *parms = &voice->Chan[chan].Direct;
 559                 const ALfloat *samples;
 560
 561                 samples = DoFilters(
 562                     &parms->LowPass, &parms->HighPass, Device->FilteredData,
 563                     ResampledData, DstBufferSize, parms->FilterType
 564                 );
 565                 if(!voice->IsHrtf)
 566                 {
 567                     if(!Counter)
 568                         memcpy(parms->Gains.Current, parms->Gains.Target,
 569                                sizeof(parms->Gains.Current));
 570                     MixSamples(samples, voice->DirectOut.Channels, voice->DirectOut.Buffer,
 571                         parms->Gains.Current, parms->Gains.Target, Counter, OutPos, DstBufferSize
 572                     );
 573                 }
 574                 else
 575                 {
 576                     MixHrtfParams hrtfparams;
 577                     int lidx, ridx;
 578
 579                     if(!Counter)
 580                     {
 581                         parms->Hrtf.Current = parms->Hrtf.Target;
 582                         for(j = 0;j < HRIR_LENGTH;j++)
 583                         {
 584                             hrtfparams.Steps.Coeffs[j][0] = 0.0f;
 585                             hrtfparams.Steps.Coeffs[j][1] = 0.0f;
 586                         }
 587                         hrtfparams.Steps.Delay[0] = 0;
 588                         hrtfparams.Steps.Delay[1] = 0;
 589                     }
 590                     else
 591                     {
 592                         ALfloat delta = 1.0f / (ALfloat)Counter;
 593                         ALfloat coeffdiff;
 594                         ALint delaydiff;
 595                         for(j = 0;j < IrSize;j++)
 596                         {
 597                             coeffdiff = parms->Hrtf.Target.Coeffs[j][0] - parms->Hrtf.Current.Coeffs[j][0];
 598                             hrtfparams.Steps.Coeffs[j][0] = coeffdiff * delta;
 599                             coeffdiff = parms->Hrtf.Target.Coeffs[j][1] - parms->Hrtf.Current.Coeffs[j][1];
 600                             hrtfparams.Steps.Coeffs[j][1] = coeffdiff * delta;
 601                         }
 602                         delaydiff = (ALint)(parms->Hrtf.Target.Delay[0] - parms->Hrtf.Current.Delay[0]);
 603                         hrtfparams.Steps.Delay[0] = fastf2i((ALfloat)delaydiff * delta);
 604                         delaydiff = (ALint)(parms->Hrtf.Target.Delay[1] - parms->Hrtf.Current.Delay[1]);
 605                         hrtfparams.Steps.Delay[1] = fastf2i((ALfloat)delaydiff * delta);
 606                     }
 607                     hrtfparams.Target = &parms->Hrtf.Target;
 608                     hrtfparams.Current = &parms->Hrtf.Current;
 609
 610                     lidx = GetChannelIdxByName(Device->RealOut, FrontLeft);
 611                     ridx = GetChannelIdxByName(Device->RealOut, FrontRight);
 612                     assert(lidx != -1 && ridx != -1);
 613
 614                     MixHrtfSamples(voice->DirectOut.Buffer, lidx, ridx, samples, Counter,
 615                                    voice->Offset, OutPos, IrSize, &hrtfparams,
 616                                    &parms->Hrtf.State, DstBufferSize);
 617                 }
 618             }
 619
 620             for(send = 0;send < Device->NumAuxSends;send++)
 621             {
 622                 SendParams *parms = &voice->Chan[chan].Send[send];
 623                 const ALfloat *samples;
 624
 625                 if(!voice->SendOut[send].Buffer)
 626                     continue;
 627
 628                 samples = DoFilters(
 629                     &parms->LowPass, &parms->HighPass, Device->FilteredData,
 630                     ResampledData, DstBufferSize, parms->FilterType
 631                 );
 632
 633                 if(!Counter)
 634                     memcpy(parms->Gains.Current, parms->Gains.Target,
 635                            sizeof(parms->Gains.Current));
 636                 MixSamples(samples, voice->SendOut[send].Channels, voice->SendOut[send].Buffer,
 637                     parms->Gains.Current, parms->Gains.Target, Counter, OutPos, DstBufferSize
 638                 );
 639             }
 640         }
 641         /* Update positions */
 642         DataPosFrac += increment*DstBufferSize;
 643         DataPosInt  += DataPosFrac>>FRACTIONBITS;
 644         DataPosFrac &= FRACTIONMASK;
 645
 646         OutPos += DstBufferSize;
 647         voice->Offset += DstBufferSize;
 648         Counter = maxu(DstBufferSize, Counter) - DstBufferSize;
 649
 650         /* Handle looping sources */
 651         while(1)
 652         {
 653             const ALbuffer *ALBuffer;
 654             ALuint DataSize = 0;
 655             ALuint LoopStart = 0;
 656             ALuint LoopEnd = 0;
 657
 658             if((ALBuffer=BufferListItem->buffer) != NULL)
 659             {
 660                 DataSize = ALBuffer->SampleLen;
 661                 LoopStart = ALBuffer->LoopStart;
 662                 LoopEnd = ALBuffer->LoopEnd;
 663                 if(LoopEnd > DataPosInt)
 664                     break;
 665             }
 666
 667             if(Looping && Source->SourceType == AL_STATIC)
 668             {
 669                 assert(LoopEnd > LoopStart);
 670                 DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
 671                 break;
 672             }
 673
 674             if(DataSize > DataPosInt)
 675                 break;
 676
 677             if(!(BufferListItem=BufferListItem->next))
 678             {
 679                 if(Looping)
 680                     BufferListItem = ATOMIC_LOAD(&Source->queue);
 681                 else
 682                 {
 683                     State = AL_STOPPED;
 684                     BufferListItem = NULL;
 685                     DataPosInt = 0;
 686                     DataPosFrac = 0;
 687                     break;
 688                 }
 689             }
 690
 691             DataPosInt -= DataSize;
 692         }
 693     } while(State == AL_PLAYING && OutPos < SamplesToDo);
 694
 695     voice->Moving = AL_TRUE;
 696
 697     /* Update source info */
 698     Source->state = State;
 699     ATOMIC_STORE(&Source->current_buffer,    BufferListItem, almemory_order_relaxed);
 700     ATOMIC_STORE(&Source->position,          DataPosInt, almemory_order_relaxed);
 701     ATOMIC_STORE(&Source->position_fraction, DataPosFrac);
 702 }