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., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, 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 #include "bs2b.h"
  38
  39
  40 static __inline ALfloat point32(const ALfloat *vals, ALint step, ALint frac)
  41 { return vals[0]; (void)step; (void)frac; }
  42 static __inline ALfloat lerp32(const ALfloat *vals, ALint step, ALint frac)
  43 { return lerp(vals[0], vals[step], frac * (1.0f/FRACTIONONE)); }
  44 static __inline ALfloat cubic32(const ALfloat *vals, ALint step, ALint frac)
  45 { return cubic(vals[-step], vals[0], vals[step], vals[step+step],
  46                frac * (1.0f/FRACTIONONE)); }
  47
  48 #ifdef __GNUC__
  49 #define LIKELY(x) __builtin_expect(!!(x), 1)
  50 #define UNLIKELY(x) __builtin_expect(!!(x), 0)
  51 #else
  52 #define LIKELY(x) (x)
  53 #define UNLIKELY(x) (x)
  54 #endif
  55
  56 #if defined(__ARM_NEON__) && defined(HAVE_ARM_NEON_H)
  57 #include <arm_neon.h>
  58
  59 static __inline void ApplyCoeffs(ALuint Offset, ALfloat (*RESTRICT Values)[2],
  60                                  ALfloat (*RESTRICT Coeffs)[2],
  61                                  ALfloat left, ALfloat right)
  62 {
  63     ALuint c;
  64     float32x4_t leftright4;
  65     {
  66         float32x2_t leftright2 = vdup_n_f32(0.0);
  67         leftright2 = vset_lane_f32(left, leftright2, 0);
  68         leftright2 = vset_lane_f32(right, leftright2, 1);
  69         leftright4 = vcombine_f32(leftright2, leftright2);
  70     }
  71     for(c = 0;c < HRIR_LENGTH;c += 2)
  72     {
  73         const ALuint o0 = (Offset+c)&HRIR_MASK;
  74         const ALuint o1 = (o0+1)&HRIR_MASK;
  75         float32x4_t vals = vcombine_f32(vld1_f32((float32_t*)&Values[o0][0]),
  76                                         vld1_f32((float32_t*)&Values[o1][0]));
  77         float32x4_t coefs = vld1q_f32((float32_t*)&Coeffs[c][0]);
  78
  79         vals = vmlaq_f32(vals, coefs, leftright4);
  80
  81         vst1_f32((float32_t*)&Values[o0][0], vget_low_f32(vals));
  82         vst1_f32((float32_t*)&Values[o1][0], vget_high_f32(vals));
  83     }
  84 }
  85
  86 #else
  87
  88 static __inline void ApplyCoeffs(ALuint Offset, ALfloat (*RESTRICT Values)[2],
  89                                  ALfloat (*RESTRICT Coeffs)[2],
  90                                  ALfloat left, ALfloat right)
  91 {
  92     ALuint c;
  93     for(c = 0;c < HRIR_LENGTH;c++)
  94     {
  95         const ALuint off = (Offset+c)&HRIR_MASK;
  96         Values[off][0] += Coeffs[c][0] * left;
  97         Values[off][1] += Coeffs[c][1] * right;
  98     }
  99 }
 100
 101 #endif
 102
 103 #define DECL_TEMPLATE(T, sampler)                                             \
 104 static void Mix_Hrtf_##T##_##sampler(ALsource *Source, ALCdevice *Device,     \
 105   const ALvoid *srcdata, ALuint srcfrac, ALuint OutPos, ALuint SamplesToDo,   \
 106   ALuint BufferSize)                                                          \
 107 {                                                                             \
 108     const ALuint NumChannels = Source->NumChannels;                           \
 109     const T *RESTRICT data = srcdata;                                         \
 110     const ALint *RESTRICT DelayStep = Source->Params.HrtfDelayStep;           \
 111     ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS];                               \
 112     ALfloat *RESTRICT ClickRemoval, *RESTRICT PendingClicks;                  \
 113     ALfloat (*RESTRICT CoeffStep)[2] = Source->Params.HrtfCoeffStep;          \
 114     ALuint pos, frac;                                                         \
 115     FILTER *DryFilter;                                                        \
 116     ALuint BufferIdx;                                                         \
 117     ALuint increment;                                                         \
 118     ALuint i, out, c;                                                         \
 119     ALfloat value;                                                            \
 120                                                                               \
 121     increment = Source->Params.Step;                                          \
 122                                                                               \
 123     DryBuffer = Device->DryBuffer;                                            \
 124     ClickRemoval = Device->ClickRemoval;                                      \
 125     PendingClicks = Device->PendingClicks;                                    \
 126     DryFilter = &Source->Params.iirFilter;                                    \
 127                                                                               \
 128     pos = 0;                                                                  \
 129     frac = srcfrac;                                                           \
 130                                                                               \
 131     for(i = 0;i < NumChannels;i++)                                            \
 132     {                                                                         \
 133         ALfloat (*RESTRICT TargetCoeffs)[2] = Source->Params.HrtfCoeffs[i];   \
 134         ALuint *RESTRICT TargetDelay = Source->Params.HrtfDelay[i];           \
 135         ALfloat *RESTRICT History = Source->HrtfHistory[i];                   \
 136         ALfloat (*RESTRICT Values)[2] = Source->HrtfValues[i];                \
 137         ALint Counter = maxu(Source->HrtfCounter, OutPos) - OutPos;           \
 138         ALuint Offset = Source->HrtfOffset + OutPos;                          \
 139         ALfloat Coeffs[HRIR_LENGTH][2];                                       \
 140         ALuint Delay[2];                                                      \
 141         ALfloat left, right;                                                  \
 142                                                                               \
 143         pos = 0;                                                              \
 144         frac = srcfrac;                                                       \
 145                                                                               \
 146         for(c = 0;c < HRIR_LENGTH;c++)                                        \
 147         {                                                                     \
 148             Coeffs[c][0] = TargetCoeffs[c][0] - (CoeffStep[c][0]*Counter);    \
 149             Coeffs[c][1] = TargetCoeffs[c][1] - (CoeffStep[c][1]*Counter);    \
 150         }                                                                     \
 151                                                                               \
 152         Delay[0] = TargetDelay[0] - (DelayStep[0]*Counter) + 32768;           \
 153         Delay[1] = TargetDelay[1] - (DelayStep[1]*Counter) + 32768;           \
 154                                                                               \
 155         if(LIKELY(OutPos == 0))                                               \
 156         {                                                                     \
 157             value = sampler(data + pos*NumChannels + i, NumChannels, frac);   \
 158             value = lpFilter2PC(DryFilter, i, value);                         \
 159                                                                               \
 160             History[Offset&SRC_HISTORY_MASK] = value;                         \
 161             left = History[(Offset-(Delay[0]>>16))&SRC_HISTORY_MASK];         \
 162             right = History[(Offset-(Delay[1]>>16))&SRC_HISTORY_MASK];        \
 163                                                                               \
 164             ClickRemoval[FRONT_LEFT]  -= Values[(Offset+1)&HRIR_MASK][0] +    \
 165                                          Coeffs[0][0] * left;                 \
 166             ClickRemoval[FRONT_RIGHT] -= Values[(Offset+1)&HRIR_MASK][1] +    \
 167                                          Coeffs[0][1] * right;                \
 168         }                                                                     \
 169         for(BufferIdx = 0;BufferIdx < BufferSize && Counter > 0;BufferIdx++)  \
 170         {                                                                     \
 171             value = sampler(data + pos*NumChannels + i, NumChannels, frac);   \
 172             value = lpFilter2P(DryFilter, i, value);                          \
 173                                                                               \
 174             History[Offset&SRC_HISTORY_MASK] = value;                         \
 175             left = History[(Offset-(Delay[0]>>16))&SRC_HISTORY_MASK];         \
 176             right = History[(Offset-(Delay[1]>>16))&SRC_HISTORY_MASK];        \
 177                                                                               \
 178             Delay[0] += DelayStep[0];                                         \
 179             Delay[1] += DelayStep[1];                                         \
 180                                                                               \
 181             Values[Offset&HRIR_MASK][0] = 0.0f;                               \
 182             Values[Offset&HRIR_MASK][1] = 0.0f;                               \
 183             Offset++;                                                         \
 184                                                                               \
 185             for(c = 0;c < HRIR_LENGTH;c++)                                    \
 186             {                                                                 \
 187                 const ALuint off = (Offset+c)&HRIR_MASK;                      \
 188                 Values[off][0] += Coeffs[c][0] * left;                        \
 189                 Values[off][1] += Coeffs[c][1] * right;                       \
 190                 Coeffs[c][0] += CoeffStep[c][0];                              \
 191                 Coeffs[c][1] += CoeffStep[c][1];                              \
 192             }                                                                 \
 193                                                                               \
 194             DryBuffer[OutPos][FRONT_LEFT]  += Values[Offset&HRIR_MASK][0];    \
 195             DryBuffer[OutPos][FRONT_RIGHT] += Values[Offset&HRIR_MASK][1];    \
 196                                                                               \
 197             frac += increment;                                                \
 198             pos  += frac>>FRACTIONBITS;                                       \
 199             frac &= FRACTIONMASK;                                             \
 200             OutPos++;                                                         \
 201             Counter--;                                                        \
 202         }                                                                     \
 203                                                                               \
 204         Delay[0] >>= 16;                                                      \
 205         Delay[1] >>= 16;                                                      \
 206         for(;BufferIdx < BufferSize;BufferIdx++)                              \
 207         {                                                                     \
 208             value = sampler(data + pos*NumChannels + i, NumChannels, frac);   \
 209             value = lpFilter2P(DryFilter, i, value);                          \
 210                                                                               \
 211             History[Offset&SRC_HISTORY_MASK] = value;                         \
 212             left = History[(Offset-Delay[0])&SRC_HISTORY_MASK];               \
 213             right = History[(Offset-Delay[1])&SRC_HISTORY_MASK];              \
 214                                                                               \
 215             Values[Offset&HRIR_MASK][0] = 0.0f;                               \
 216             Values[Offset&HRIR_MASK][1] = 0.0f;                               \
 217             Offset++;                                                         \
 218                                                                               \
 219             ApplyCoeffs(Offset, Values, Coeffs, left, right);                 \
 220             DryBuffer[OutPos][FRONT_LEFT]  += Values[Offset&HRIR_MASK][0];    \
 221             DryBuffer[OutPos][FRONT_RIGHT] += Values[Offset&HRIR_MASK][1];    \
 222                                                                               \
 223             frac += increment;                                                \
 224             pos  += frac>>FRACTIONBITS;                                       \
 225             frac &= FRACTIONMASK;                                             \
 226             OutPos++;                                                         \
 227         }                                                                     \
 228         if(LIKELY(OutPos == SamplesToDo))                                     \
 229         {                                                                     \
 230             value = sampler(data + pos*NumChannels + i, NumChannels, frac);   \
 231             value = lpFilter2PC(DryFilter, i, value);                         \
 232                                                                               \
 233             History[Offset&SRC_HISTORY_MASK] = value;                         \
 234             left = History[(Offset-Delay[0])&SRC_HISTORY_MASK];               \
 235             right = History[(Offset-Delay[1])&SRC_HISTORY_MASK];              \
 236                                                                               \
 237             PendingClicks[FRONT_LEFT]  += Values[(Offset+1)&HRIR_MASK][0] +   \
 238                                           Coeffs[0][0] * left;                \
 239             PendingClicks[FRONT_RIGHT] += Values[(Offset+1)&HRIR_MASK][1] +   \
 240                                           Coeffs[0][1] * right;               \
 241         }                                                                     \
 242         OutPos -= BufferSize;                                                 \
 243     }                                                                         \
 244                                                                               \
 245     for(out = 0;out < Device->NumAuxSends;out++)                              \
 246     {                                                                         \
 247         ALeffectslot *Slot = Source->Params.Send[out].Slot;                   \
 248         ALfloat  WetSend;                                                     \
 249         ALfloat *RESTRICT WetBuffer;                                          \
 250         ALfloat *RESTRICT WetClickRemoval;                                    \
 251         ALfloat *RESTRICT WetPendingClicks;                                   \
 252         FILTER  *WetFilter;                                                   \
 253                                                                               \
 254         if(Slot == NULL)                                                      \
 255             continue;                                                         \
 256                                                                               \
 257         WetBuffer = Slot->WetBuffer;                                          \
 258         WetClickRemoval = Slot->ClickRemoval;                                 \
 259         WetPendingClicks = Slot->PendingClicks;                               \
 260         WetFilter = &Source->Params.Send[out].iirFilter;                      \
 261         WetSend = Source->Params.Send[out].WetGain;                           \
 262                                                                               \
 263         for(i = 0;i < NumChannels;i++)                                        \
 264         {                                                                     \
 265             pos = 0;                                                          \
 266             frac = srcfrac;                                                   \
 267                                                                               \
 268             if(LIKELY(OutPos == 0))                                           \
 269             {                                                                 \
 270                 value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
 271                 value = lpFilter1PC(WetFilter, i, value);                     \
 272                                                                               \
 273                 WetClickRemoval[0] -= value * WetSend;                        \
 274             }                                                                 \
 275             for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++)             \
 276             {                                                                 \
 277                 value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
 278                 value = lpFilter1P(WetFilter, i, value);                      \
 279                                                                               \
 280                 WetBuffer[OutPos] += value * WetSend;                         \
 281                                                                               \
 282                 frac += increment;                                            \
 283                 pos  += frac>>FRACTIONBITS;                                   \
 284                 frac &= FRACTIONMASK;                                         \
 285                 OutPos++;                                                     \
 286             }                                                                 \
 287             if(LIKELY(OutPos == SamplesToDo))                                 \
 288             {                                                                 \
 289                 value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
 290                 value = lpFilter1PC(WetFilter, i, value);                     \
 291                                                                               \
 292                 WetPendingClicks[0] += value * WetSend;                       \
 293             }                                                                 \
 294             OutPos -= BufferSize;                                             \
 295         }                                                                     \
 296     }                                                                         \
 297 }
 298
 299 DECL_TEMPLATE(ALfloat, point32)
 300 DECL_TEMPLATE(ALfloat, lerp32)
 301 DECL_TEMPLATE(ALfloat, cubic32)
 302
 303 #undef DECL_TEMPLATE
 304
 305
 306 #define DECL_TEMPLATE(T, sampler)                                             \
 307 static void Mix_##T##_##sampler(ALsource *Source, ALCdevice *Device,          \
 308   const ALvoid *srcdata, ALuint srcfrac, ALuint OutPos, ALuint SamplesToDo,   \
 309   ALuint BufferSize)                                                          \
 310 {                                                                             \
 311     const ALuint NumChannels = Source->NumChannels;                           \
 312     const T *RESTRICT data = srcdata;                                         \
 313     ALfloat (*RESTRICT DryBuffer)[MAXCHANNELS];                               \
 314     ALfloat *RESTRICT ClickRemoval, *RESTRICT PendingClicks;                  \
 315     ALfloat DrySend[MAXCHANNELS];                                             \
 316     FILTER *DryFilter;                                                        \
 317     ALuint pos, frac;                                                         \
 318     ALuint BufferIdx;                                                         \
 319     ALuint increment;                                                         \
 320     ALuint i, out, c;                                                         \
 321     ALfloat value;                                                            \
 322                                                                               \
 323     increment = Source->Params.Step;                                          \
 324                                                                               \
 325     DryBuffer = Device->DryBuffer;                                            \
 326     ClickRemoval = Device->ClickRemoval;                                      \
 327     PendingClicks = Device->PendingClicks;                                    \
 328     DryFilter = &Source->Params.iirFilter;                                    \
 329                                                                               \
 330     pos = 0;                                                                  \
 331     frac = srcfrac;                                                           \
 332                                                                               \
 333     for(i = 0;i < NumChannels;i++)                                            \
 334     {                                                                         \
 335         for(c = 0;c < MAXCHANNELS;c++)                                        \
 336             DrySend[c] = Source->Params.DryGains[i][c];                       \
 337                                                                               \
 338         pos = 0;                                                              \
 339         frac = srcfrac;                                                       \
 340                                                                               \
 341         if(OutPos == 0)                                                       \
 342         {                                                                     \
 343             value = sampler(data + pos*NumChannels + i, NumChannels, frac);   \
 344                                                                               \
 345             value = lpFilter2PC(DryFilter, i, value);                         \
 346             for(c = 0;c < MAXCHANNELS;c++)                                    \
 347                 ClickRemoval[c] -= value*DrySend[c];                          \
 348         }                                                                     \
 349         for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++)                 \
 350         {                                                                     \
 351             value = sampler(data + pos*NumChannels + i, NumChannels, frac);   \
 352                                                                               \
 353             value = lpFilter2P(DryFilter, i, value);                          \
 354             for(c = 0;c < MAXCHANNELS;c++)                                    \
 355                 DryBuffer[OutPos][c] += value*DrySend[c];                     \
 356                                                                               \
 357             frac += increment;                                                \
 358             pos  += frac>>FRACTIONBITS;                                       \
 359             frac &= FRACTIONMASK;                                             \
 360             OutPos++;                                                         \
 361         }                                                                     \
 362         if(OutPos == SamplesToDo)                                             \
 363         {                                                                     \
 364             value = sampler(data + pos*NumChannels + i, NumChannels, frac);   \
 365                                                                               \
 366             value = lpFilter2PC(DryFilter, i, value);                         \
 367             for(c = 0;c < MAXCHANNELS;c++)                                    \
 368                 PendingClicks[c] += value*DrySend[c];                         \
 369         }                                                                     \
 370         OutPos -= BufferSize;                                                 \
 371     }                                                                         \
 372                                                                               \
 373     for(out = 0;out < Device->NumAuxSends;out++)                              \
 374     {                                                                         \
 375         ALeffectslot *Slot = Source->Params.Send[out].Slot;                   \
 376         ALfloat  WetSend;                                                     \
 377         ALfloat *WetBuffer;                                                   \
 378         ALfloat *WetClickRemoval;                                             \
 379         ALfloat *WetPendingClicks;                                            \
 380         FILTER  *WetFilter;                                                   \
 381                                                                               \
 382         if(Slot == NULL)                                                      \
 383             continue;                                                         \
 384                                                                               \
 385         WetBuffer = Slot->WetBuffer;                                          \
 386         WetClickRemoval = Slot->ClickRemoval;                                 \
 387         WetPendingClicks = Slot->PendingClicks;                               \
 388         WetFilter = &Source->Params.Send[out].iirFilter;                      \
 389         WetSend = Source->Params.Send[out].WetGain;                           \
 390                                                                               \
 391         for(i = 0;i < NumChannels;i++)                                        \
 392         {                                                                     \
 393             pos = 0;                                                          \
 394             frac = srcfrac;                                                   \
 395                                                                               \
 396             if(OutPos == 0)                                                   \
 397             {                                                                 \
 398                 value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
 399                                                                               \
 400                 value = lpFilter1PC(WetFilter, i, value);                     \
 401                 WetClickRemoval[0] -= value * WetSend;                        \
 402             }                                                                 \
 403             for(BufferIdx = 0;BufferIdx < BufferSize;BufferIdx++)             \
 404             {                                                                 \
 405                 value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
 406                                                                               \
 407                 value = lpFilter1P(WetFilter, i, value);                      \
 408                 WetBuffer[OutPos] += value * WetSend;                         \
 409                                                                               \
 410                 frac += increment;                                            \
 411                 pos  += frac>>FRACTIONBITS;                                   \
 412                 frac &= FRACTIONMASK;                                         \
 413                 OutPos++;                                                     \
 414             }                                                                 \
 415             if(OutPos == SamplesToDo)                                         \
 416             {                                                                 \
 417                 value = sampler(data + pos*NumChannels + i, NumChannels,frac);\
 418                                                                               \
 419                 value = lpFilter1PC(WetFilter, i, value);                     \
 420                 WetPendingClicks[0] += value * WetSend;                       \
 421             }                                                                 \
 422             OutPos -= BufferSize;                                             \
 423         }                                                                     \
 424     }                                                                         \
 425 }
 426
 427 DECL_TEMPLATE(ALfloat, point32)
 428 DECL_TEMPLATE(ALfloat, lerp32)
 429 DECL_TEMPLATE(ALfloat, cubic32)
 430
 431 #undef DECL_TEMPLATE
 432
 433
 434 MixerFunc SelectMixer(enum Resampler Resampler)
 435 {
 436     switch(Resampler)
 437     {
 438         case PointResampler:
 439             return Mix_ALfloat_point32;
 440         case LinearResampler:
 441             return Mix_ALfloat_lerp32;
 442         case CubicResampler:
 443             return Mix_ALfloat_cubic32;
 444         case ResamplerMax:
 445             break;
 446     }
 447     return NULL;
 448 }
 449
 450 MixerFunc SelectHrtfMixer(enum Resampler Resampler)
 451 {
 452     switch(Resampler)
 453     {
 454         case PointResampler:
 455             return Mix_Hrtf_ALfloat_point32;
 456         case LinearResampler:
 457             return Mix_Hrtf_ALfloat_lerp32;
 458         case CubicResampler:
 459             return Mix_Hrtf_ALfloat_cubic32;
 460         case ResamplerMax:
 461             break;
 462     }
 463     return NULL;
 464 }
 465
 466
 467 static __inline ALfloat Sample_ALbyte(ALbyte val)
 468 { return val * (1.0f/127.0f); }
 469
 470 static __inline ALfloat Sample_ALshort(ALshort val)
 471 { return val * (1.0f/32767.0f); }
 472
 473 static __inline ALfloat Sample_ALfloat(ALfloat val)
 474 { return val; }
 475
 476 #define DECL_TEMPLATE(T)                                                      \
 477 static void Load_##T(ALfloat *dst, const T *src, ALuint samples)              \
 478 {                                                                             \
 479     ALuint i;                                                                 \
 480     for(i = 0;i < samples;i++)                                                \
 481         dst[i] = Sample_##T(src[i]);                                          \
 482 }
 483
 484 DECL_TEMPLATE(ALbyte)
 485 DECL_TEMPLATE(ALshort)
 486 DECL_TEMPLATE(ALfloat)
 487
 488 #undef DECL_TEMPLATE
 489
 490 static void LoadStack(ALfloat *dst, const ALvoid *src, enum FmtType srctype, ALuint samples)
 491 {
 492     switch(srctype)
 493     {
 494         case FmtByte:
 495             Load_ALbyte(dst, src, samples);
 496             break;
 497         case FmtShort:
 498             Load_ALshort(dst, src, samples);
 499             break;
 500         case FmtFloat:
 501             Load_ALfloat(dst, src, samples);
 502             break;
 503     }
 504 }
 505
 506 static void SilenceStack(ALfloat *dst, ALuint samples)
 507 {
 508     ALuint i;
 509     for(i = 0;i < samples;i++)
 510         dst[i] = 0.0f;
 511 }
 512
 513
 514 ALvoid MixSource(ALsource *Source, ALCdevice *Device, ALuint SamplesToDo)
 515 {
 516     ALbufferlistitem *BufferListItem;
 517     ALuint DataPosInt, DataPosFrac;
 518     ALuint BuffersPlayed;
 519     ALboolean Looping;
 520     ALuint increment;
 521     enum Resampler Resampler;
 522     ALenum State;
 523     ALuint OutPos;
 524     ALuint NumChannels;
 525     ALuint FrameSize;
 526     ALint64 DataSize64;
 527     ALuint i;
 528
 529     /* Get source info */
 530     State         = Source->state;
 531     BuffersPlayed = Source->BuffersPlayed;
 532     DataPosInt    = Source->position;
 533     DataPosFrac   = Source->position_fraction;
 534     Looping       = Source->Looping;
 535     increment     = Source->Params.Step;
 536     Resampler     = Source->Resampler;
 537     NumChannels   = Source->NumChannels;
 538     FrameSize     = NumChannels * Source->SampleSize;
 539
 540     /* Get current buffer queue item */
 541     BufferListItem = Source->queue;
 542     for(i = 0;i < BuffersPlayed;i++)
 543         BufferListItem = BufferListItem->next;
 544
 545     OutPos = 0;
 546     do {
 547         const ALuint BufferPrePadding = ResamplerPrePadding[Resampler];
 548         const ALuint BufferPadding = ResamplerPadding[Resampler];
 549         ALfloat StackData[STACK_DATA_SIZE/sizeof(ALfloat)];
 550         ALfloat *SrcData = StackData;
 551         ALuint SrcDataSize = 0;
 552         ALuint BufferSize;
 553
 554         /* Figure out how many buffer bytes will be needed */
 555         DataSize64  = SamplesToDo-OutPos+1;
 556         DataSize64 *= increment;
 557         DataSize64 += DataPosFrac+FRACTIONMASK;
 558         DataSize64 >>= FRACTIONBITS;
 559         DataSize64 += BufferPadding+BufferPrePadding;
 560         DataSize64 *= NumChannels;
 561
 562         BufferSize  = (ALuint)mini64(DataSize64, STACK_DATA_SIZE/sizeof(ALfloat));
 563         BufferSize /= NumChannels;
 564
 565         if(Source->SourceType == AL_STATIC)
 566         {
 567             const ALbuffer *ALBuffer = Source->queue->buffer;
 568             const ALubyte *Data = ALBuffer->data;
 569             ALuint DataSize;
 570             ALuint pos;
 571
 572             /* If current pos is beyond the loop range, do not loop */
 573             if(Looping == AL_FALSE || DataPosInt >= (ALuint)ALBuffer->LoopEnd)
 574             {
 575                 Looping = AL_FALSE;
 576
 577                 if(DataPosInt >= BufferPrePadding)
 578                     pos = DataPosInt - BufferPrePadding;
 579                 else
 580                 {
 581                     DataSize = BufferPrePadding - DataPosInt;
 582                     DataSize = minu(BufferSize, DataSize);
 583
 584                     SilenceStack(&SrcData[SrcDataSize*NumChannels],
 585                                  DataSize*NumChannels);
 586                     SrcDataSize += DataSize;
 587                     BufferSize -= DataSize;
 588
 589                     pos = 0;
 590                 }
 591
 592                 /* Copy what's left to play in the source buffer, and clear the
 593                  * rest of the temp buffer */
 594                 DataSize = ALBuffer->SampleLen - pos;
 595                 DataSize = minu(BufferSize, DataSize);
 596
 597                 LoadStack(&SrcData[SrcDataSize*NumChannels], &Data[pos*FrameSize],
 598                           ALBuffer->FmtType, DataSize*NumChannels);
 599                 SrcDataSize += DataSize;
 600                 BufferSize -= DataSize;
 601
 602                 SilenceStack(&SrcData[SrcDataSize*NumChannels],
 603                              BufferSize*NumChannels);
 604                 SrcDataSize += BufferSize;
 605                 BufferSize -= BufferSize;
 606             }
 607             else
 608             {
 609                 ALuint LoopStart = ALBuffer->LoopStart;
 610                 ALuint LoopEnd   = ALBuffer->LoopEnd;
 611
 612                 if(DataPosInt >= LoopStart)
 613                 {
 614                     pos = DataPosInt-LoopStart;
 615                     while(pos < BufferPrePadding)
 616                         pos += LoopEnd-LoopStart;
 617                     pos -= BufferPrePadding;
 618                     pos += LoopStart;
 619                 }
 620                 else if(DataPosInt >= BufferPrePadding)
 621                     pos = DataPosInt - BufferPrePadding;
 622                 else
 623                 {
 624                     DataSize = BufferPrePadding - DataPosInt;
 625                     DataSize = minu(BufferSize, DataSize);
 626
 627                     SilenceStack(&SrcData[SrcDataSize*NumChannels], DataSize*NumChannels);
 628                     SrcDataSize += DataSize;
 629                     BufferSize -= DataSize;
 630
 631                     pos = 0;
 632                 }
 633
 634                 /* Copy what's left of this loop iteration, then copy repeats
 635                  * of the loop section */
 636                 DataSize = LoopEnd - pos;
 637                 DataSize = minu(BufferSize, DataSize);
 638
 639                 LoadStack(&SrcData[SrcDataSize*NumChannels], &Data[pos*FrameSize],
 640                           ALBuffer->FmtType, DataSize*NumChannels);
 641                 SrcDataSize += DataSize;
 642                 BufferSize -= DataSize;
 643
 644                 DataSize = LoopEnd-LoopStart;
 645                 while(BufferSize > 0)
 646                 {
 647                     DataSize = minu(BufferSize, DataSize);
 648
 649                     LoadStack(&SrcData[SrcDataSize*NumChannels], &Data[LoopStart*FrameSize],
 650                               ALBuffer->FmtType, DataSize*NumChannels);
 651                     SrcDataSize += DataSize;
 652                     BufferSize -= DataSize;
 653                 }
 654             }
 655         }
 656         else
 657         {
 658             /* Crawl the buffer queue to fill in the temp buffer */
 659             ALbufferlistitem *tmpiter = BufferListItem;
 660             ALuint pos;
 661
 662             if(DataPosInt >= BufferPrePadding)
 663                 pos = DataPosInt - BufferPrePadding;
 664             else
 665             {
 666                 pos = BufferPrePadding - DataPosInt;
 667                 while(pos > 0)
 668                 {
 669                     if(!tmpiter->prev && !Looping)
 670                     {
 671                         ALuint DataSize = minu(BufferSize, pos);
 672
 673                         SilenceStack(&SrcData[SrcDataSize*NumChannels], DataSize*NumChannels);
 674                         SrcDataSize += DataSize;
 675                         BufferSize -= DataSize;
 676
 677                         pos = 0;
 678                         break;
 679                     }
 680
 681                     if(tmpiter->prev)
 682                         tmpiter = tmpiter->prev;
 683                     else
 684                     {
 685                         while(tmpiter->next)
 686                             tmpiter = tmpiter->next;
 687                     }
 688
 689                     if(tmpiter->buffer)
 690                     {
 691                         if((ALuint)tmpiter->buffer->SampleLen > pos)
 692                         {
 693                             pos = tmpiter->buffer->SampleLen - pos;
 694                             break;
 695                         }
 696                         pos -= tmpiter->buffer->SampleLen;
 697                     }
 698                 }
 699             }
 700
 701             while(tmpiter && BufferSize > 0)
 702             {
 703                 const ALbuffer *ALBuffer;
 704                 if((ALBuffer=tmpiter->buffer) != NULL)
 705                 {
 706                     const ALubyte *Data = ALBuffer->data;
 707                     ALuint DataSize = ALBuffer->SampleLen;
 708
 709                     /* Skip the data already played */
 710                     if(DataSize <= pos)
 711                         pos -= DataSize;
 712                     else
 713                     {
 714                         Data += pos*FrameSize;
 715                         DataSize -= pos;
 716                         pos -= pos;
 717
 718                         DataSize = minu(BufferSize, DataSize);
 719                         LoadStack(&SrcData[SrcDataSize*NumChannels], Data,
 720                                   ALBuffer->FmtType, DataSize*NumChannels);
 721                         SrcDataSize += DataSize;
 722                         BufferSize -= DataSize;
 723                     }
 724                 }
 725                 tmpiter = tmpiter->next;
 726                 if(!tmpiter && Looping)
 727                     tmpiter = Source->queue;
 728                 else if(!tmpiter)
 729                 {
 730                     SilenceStack(&SrcData[SrcDataSize*NumChannels], BufferSize*NumChannels);
 731                     SrcDataSize += BufferSize;
 732                     BufferSize -= BufferSize;
 733                 }
 734             }
 735         }
 736
 737         /* Figure out how many samples we can mix. */
 738         DataSize64  = SrcDataSize;
 739         DataSize64 -= BufferPadding+BufferPrePadding;
 740         DataSize64 <<= FRACTIONBITS;
 741         DataSize64 -= increment;
 742         DataSize64 -= DataPosFrac;
 743
 744         BufferSize = (ALuint)((DataSize64+(increment-1)) / increment);
 745         BufferSize = minu(BufferSize, (SamplesToDo-OutPos));
 746
 747         SrcData += BufferPrePadding*NumChannels;
 748         Source->Params.DoMix(Source, Device, SrcData, DataPosFrac,
 749                              OutPos, SamplesToDo, BufferSize);
 750         for(i = 0;i < BufferSize;i++)
 751         {
 752             DataPosFrac += increment;
 753             DataPosInt  += DataPosFrac>>FRACTIONBITS;
 754             DataPosFrac &= FRACTIONMASK;
 755             OutPos++;
 756         }
 757
 758         /* Handle looping sources */
 759         while(1)
 760         {
 761             const ALbuffer *ALBuffer;
 762             ALuint DataSize = 0;
 763             ALuint LoopStart = 0;
 764             ALuint LoopEnd = 0;
 765
 766             if((ALBuffer=BufferListItem->buffer) != NULL)
 767             {
 768                 DataSize = ALBuffer->SampleLen;
 769                 LoopStart = ALBuffer->LoopStart;
 770                 LoopEnd = ALBuffer->LoopEnd;
 771                 if(LoopEnd > DataPosInt)
 772                     break;
 773             }
 774
 775             if(Looping && Source->SourceType == AL_STATIC)
 776             {
 777                 DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
 778                 break;
 779             }
 780
 781             if(DataSize > DataPosInt)
 782                 break;
 783
 784             if(BufferListItem->next)
 785             {
 786                 BufferListItem = BufferListItem->next;
 787                 BuffersPlayed++;
 788             }
 789             else if(Looping)
 790             {
 791                 BufferListItem = Source->queue;
 792                 BuffersPlayed = 0;
 793             }
 794             else
 795             {
 796                 State = AL_STOPPED;
 797                 BufferListItem = Source->queue;
 798                 BuffersPlayed = Source->BuffersInQueue;
 799                 DataPosInt = 0;
 800                 DataPosFrac = 0;
 801                 break;
 802             }
 803
 804             DataPosInt -= DataSize;
 805         }
 806     } while(State == AL_PLAYING && OutPos < SamplesToDo);
 807
 808     /* Update source info */
 809     Source->state             = State;
 810     Source->BuffersPlayed     = BuffersPlayed;
 811     Source->position          = DataPosInt;
 812     Source->position_fraction = DataPosFrac;
 813     Source->HrtfOffset       += OutPos;
 814     if(State == AL_PLAYING)
 815     {
 816         Source->HrtfCounter = maxu(Source->HrtfCounter, OutPos) - OutPos;
 817         Source->HrtfMoving  = AL_TRUE;
 818     }
 819     else
 820     {
 821         Source->HrtfCounter = 0;
 822         Source->HrtfMoving  = AL_FALSE;
 823     }
 824 }