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 #include "mixer_defs.h"
  40
  41
  42 DryMixerFunc SelectDirectMixer(void)
  43 {
  44 #ifdef HAVE_SSE
  45     if((CPUCapFlags&CPU_CAP_SSE))
  46         return MixDirect_SSE;
  47 #endif
  48 #ifdef HAVE_NEON
  49     if((CPUCapFlags&CPU_CAP_NEON))
  50         return MixDirect_Neon;
  51 #endif
  52
  53     return MixDirect_C;
  54 }
  55
  56 DryMixerFunc SelectHrtfMixer(void)
  57 {
  58 #ifdef HAVE_SSE
  59     if((CPUCapFlags&CPU_CAP_SSE))
  60         return MixDirect_Hrtf_SSE;
  61 #endif
  62 #ifdef HAVE_NEON
  63     if((CPUCapFlags&CPU_CAP_NEON))
  64         return MixDirect_Hrtf_Neon;
  65 #endif
  66
  67     return MixDirect_Hrtf_C;
  68 }
  69
  70 WetMixerFunc SelectSendMixer(void)
  71 {
  72 #ifdef HAVE_SSE
  73     if((CPUCapFlags&CPU_CAP_SSE))
  74         return MixSend_SSE;
  75 #endif
  76 #ifdef HAVE_NEON
  77     if((CPUCapFlags&CPU_CAP_NEON))
  78         return MixSend_Neon;
  79 #endif
  80
  81     return MixSend_C;
  82 }
  83
  84
  85 static __inline ALfloat Sample_ALbyte(ALbyte val)
  86 { return val * (1.0f/127.0f); }
  87
  88 static __inline ALfloat Sample_ALshort(ALshort val)
  89 { return val * (1.0f/32767.0f); }
  90
  91 static __inline ALfloat Sample_ALfloat(ALfloat val)
  92 { return val; }
  93
  94 #define DECL_TEMPLATE(T)                                                      \
  95 static void Load_##T(ALfloat *dst, const T *src, ALuint samples)              \
  96 {                                                                             \
  97     ALuint i;                                                                 \
  98     for(i = 0;i < samples;i++)                                                \
  99         dst[i] = Sample_##T(src[i]);                                          \
 100 }
 101
 102 DECL_TEMPLATE(ALbyte)
 103 DECL_TEMPLATE(ALshort)
 104 DECL_TEMPLATE(ALfloat)
 105
 106 #undef DECL_TEMPLATE
 107
 108 static void LoadStack(ALfloat *dst, const ALvoid *src, enum FmtType srctype, ALuint samples)
 109 {
 110     switch(srctype)
 111     {
 112         case FmtByte:
 113             Load_ALbyte(dst, src, samples);
 114             break;
 115         case FmtShort:
 116             Load_ALshort(dst, src, samples);
 117             break;
 118         case FmtFloat:
 119             Load_ALfloat(dst, src, samples);
 120             break;
 121     }
 122 }
 123
 124 static void SilenceStack(ALfloat *dst, ALuint samples)
 125 {
 126     ALuint i;
 127     for(i = 0;i < samples;i++)
 128         dst[i] = 0.0f;
 129 }
 130
 131
 132 static __inline ALfloat point32(const ALfloat *vals, ALint step, ALint frac)
 133 { return vals[0]; (void)step; (void)frac; }
 134 static __inline ALfloat lerp32(const ALfloat *vals, ALint step, ALint frac)
 135 { return lerp(vals[0], vals[step], frac * (1.0f/FRACTIONONE)); }
 136 static __inline ALfloat cubic32(const ALfloat *vals, ALint step, ALint frac)
 137 { return cubic(vals[-step], vals[0], vals[step], vals[step+step],
 138                frac * (1.0f/FRACTIONONE)); }
 139
 140 #define DECL_TEMPLATE(Sampler)                                                \
 141 static void Resample_##Sampler(const ALfloat *data, ALuint frac,              \
 142   ALuint increment, ALuint NumChannels, ALfloat *RESTRICT OutBuffer,          \
 143   ALuint BufferSize)                                                          \
 144 {                                                                             \
 145     ALuint pos = 0;                                                           \
 146     ALfloat value;                                                            \
 147     ALuint i;                                                                 \
 148                                                                               \
 149     for(i = 0;i < BufferSize+1;i++)                                           \
 150     {                                                                         \
 151         value = Sampler(data + pos*NumChannels, NumChannels, frac);           \
 152         OutBuffer[i] = value;                                                 \
 153                                                                               \
 154         frac += increment;                                                    \
 155         pos  += frac>>FRACTIONBITS;                                           \
 156         frac &= FRACTIONMASK;                                                 \
 157     }                                                                         \
 158 }
 159
 160 DECL_TEMPLATE(point32)
 161 DECL_TEMPLATE(lerp32)
 162 DECL_TEMPLATE(cubic32)
 163
 164 #undef DECL_TEMPLATE
 165
 166 static void Resample(enum Resampler Resampler, const ALfloat *data, ALuint frac,
 167                      ALuint increment, ALuint NumChannels,
 168                      ALfloat *RESTRICT OutBuffer, ALuint BufferSize)
 169 {
 170     if(increment == FRACTIONONE)
 171         goto do_point;
 172     switch(Resampler)
 173     {
 174         case PointResampler:
 175         do_point:
 176             Resample_point32(data, frac, increment, NumChannels,
 177                              OutBuffer, BufferSize);
 178             break;
 179         case LinearResampler:
 180             Resample_lerp32(data, frac, increment, NumChannels,
 181                             OutBuffer, BufferSize);
 182             break;
 183         case CubicResampler:
 184             Resample_cubic32(data, frac, increment, NumChannels,
 185                              OutBuffer, BufferSize);
 186             break;
 187         case ResamplerMax:
 188             /* Shouldn't happen */
 189             break;
 190     }
 191 }
 192
 193
 194 ALvoid MixSource(ALsource *Source, ALCdevice *Device, ALuint SamplesToDo)
 195 {
 196     ALbufferlistitem *BufferListItem;
 197     ALuint DataPosInt, DataPosFrac;
 198     ALuint BuffersPlayed;
 199     ALboolean Looping;
 200     ALuint increment;
 201     enum Resampler Resampler;
 202     ALenum State;
 203     ALuint OutPos;
 204     ALuint NumChannels;
 205     ALuint FrameSize;
 206     ALint64 DataSize64;
 207     ALuint i, j;
 208
 209     /* Get source info */
 210     State         = Source->state;
 211     BuffersPlayed = Source->BuffersPlayed;
 212     DataPosInt    = Source->position;
 213     DataPosFrac   = Source->position_fraction;
 214     Looping       = Source->Looping;
 215     increment     = Source->Params.Step;
 216     Resampler     = Source->Resampler;
 217     NumChannels   = Source->NumChannels;
 218     FrameSize     = NumChannels * Source->SampleSize;
 219
 220     /* Get current buffer queue item */
 221     BufferListItem = Source->queue;
 222     for(i = 0;i < BuffersPlayed;i++)
 223         BufferListItem = BufferListItem->next;
 224
 225     OutPos = 0;
 226     do {
 227         const ALuint BufferPrePadding = ResamplerPrePadding[Resampler];
 228         const ALuint BufferPadding = ResamplerPadding[Resampler];
 229         ALfloat StackData[STACK_DATA_SIZE/sizeof(ALfloat)];
 230         ALfloat *SrcData = StackData;
 231         ALuint SrcDataSize = 0;
 232         ALuint BufferSize;
 233
 234         /* Figure out how many buffer bytes will be needed */
 235         DataSize64  = SamplesToDo-OutPos+1;
 236         DataSize64 *= increment;
 237         DataSize64 += DataPosFrac+FRACTIONMASK;
 238         DataSize64 >>= FRACTIONBITS;
 239         DataSize64 += BufferPadding+BufferPrePadding;
 240         DataSize64 *= NumChannels;
 241
 242         BufferSize  = (ALuint)mini64(DataSize64, STACK_DATA_SIZE/sizeof(ALfloat));
 243         BufferSize /= NumChannels;
 244
 245         if(Source->SourceType == AL_STATIC)
 246         {
 247             const ALbuffer *ALBuffer = Source->queue->buffer;
 248             const ALubyte *Data = ALBuffer->data;
 249             ALuint DataSize;
 250             ALuint pos;
 251
 252             /* If current pos is beyond the loop range, do not loop */
 253             if(Looping == AL_FALSE || DataPosInt >= (ALuint)ALBuffer->LoopEnd)
 254             {
 255                 Looping = AL_FALSE;
 256
 257                 if(DataPosInt >= BufferPrePadding)
 258                     pos = DataPosInt - BufferPrePadding;
 259                 else
 260                 {
 261                     DataSize = BufferPrePadding - DataPosInt;
 262                     DataSize = minu(BufferSize, DataSize);
 263
 264                     SilenceStack(&SrcData[SrcDataSize*NumChannels],
 265                                  DataSize*NumChannels);
 266                     SrcDataSize += DataSize;
 267                     BufferSize -= DataSize;
 268
 269                     pos = 0;
 270                 }
 271
 272                 /* Copy what's left to play in the source buffer, and clear the
 273                  * rest of the temp buffer */
 274                 DataSize = ALBuffer->SampleLen - pos;
 275                 DataSize = minu(BufferSize, DataSize);
 276
 277                 LoadStack(&SrcData[SrcDataSize*NumChannels], &Data[pos*FrameSize],
 278                           ALBuffer->FmtType, DataSize*NumChannels);
 279                 SrcDataSize += DataSize;
 280                 BufferSize -= DataSize;
 281
 282                 SilenceStack(&SrcData[SrcDataSize*NumChannels],
 283                              BufferSize*NumChannels);
 284                 SrcDataSize += BufferSize;
 285                 BufferSize -= BufferSize;
 286             }
 287             else
 288             {
 289                 ALuint LoopStart = ALBuffer->LoopStart;
 290                 ALuint LoopEnd   = ALBuffer->LoopEnd;
 291
 292                 if(DataPosInt >= LoopStart)
 293                 {
 294                     pos = DataPosInt-LoopStart;
 295                     while(pos < BufferPrePadding)
 296                         pos += LoopEnd-LoopStart;
 297                     pos -= BufferPrePadding;
 298                     pos += LoopStart;
 299                 }
 300                 else if(DataPosInt >= BufferPrePadding)
 301                     pos = DataPosInt - BufferPrePadding;
 302                 else
 303                 {
 304                     DataSize = BufferPrePadding - DataPosInt;
 305                     DataSize = minu(BufferSize, DataSize);
 306
 307                     SilenceStack(&SrcData[SrcDataSize*NumChannels], DataSize*NumChannels);
 308                     SrcDataSize += DataSize;
 309                     BufferSize -= DataSize;
 310
 311                     pos = 0;
 312                 }
 313
 314                 /* Copy what's left of this loop iteration, then copy repeats
 315                  * of the loop section */
 316                 DataSize = LoopEnd - pos;
 317                 DataSize = minu(BufferSize, DataSize);
 318
 319                 LoadStack(&SrcData[SrcDataSize*NumChannels], &Data[pos*FrameSize],
 320                           ALBuffer->FmtType, DataSize*NumChannels);
 321                 SrcDataSize += DataSize;
 322                 BufferSize -= DataSize;
 323
 324                 DataSize = LoopEnd-LoopStart;
 325                 while(BufferSize > 0)
 326                 {
 327                     DataSize = minu(BufferSize, DataSize);
 328
 329                     LoadStack(&SrcData[SrcDataSize*NumChannels], &Data[LoopStart*FrameSize],
 330                               ALBuffer->FmtType, DataSize*NumChannels);
 331                     SrcDataSize += DataSize;
 332                     BufferSize -= DataSize;
 333                 }
 334             }
 335         }
 336         else
 337         {
 338             /* Crawl the buffer queue to fill in the temp buffer */
 339             ALbufferlistitem *tmpiter = BufferListItem;
 340             ALuint pos;
 341
 342             if(DataPosInt >= BufferPrePadding)
 343                 pos = DataPosInt - BufferPrePadding;
 344             else
 345             {
 346                 pos = BufferPrePadding - DataPosInt;
 347                 while(pos > 0)
 348                 {
 349                     if(!tmpiter->prev && !Looping)
 350                     {
 351                         ALuint DataSize = minu(BufferSize, pos);
 352
 353                         SilenceStack(&SrcData[SrcDataSize*NumChannels], DataSize*NumChannels);
 354                         SrcDataSize += DataSize;
 355                         BufferSize -= DataSize;
 356
 357                         pos = 0;
 358                         break;
 359                     }
 360
 361                     if(tmpiter->prev)
 362                         tmpiter = tmpiter->prev;
 363                     else
 364                     {
 365                         while(tmpiter->next)
 366                             tmpiter = tmpiter->next;
 367                     }
 368
 369                     if(tmpiter->buffer)
 370                     {
 371                         if((ALuint)tmpiter->buffer->SampleLen > pos)
 372                         {
 373                             pos = tmpiter->buffer->SampleLen - pos;
 374                             break;
 375                         }
 376                         pos -= tmpiter->buffer->SampleLen;
 377                     }
 378                 }
 379             }
 380
 381             while(tmpiter && BufferSize > 0)
 382             {
 383                 const ALbuffer *ALBuffer;
 384                 if((ALBuffer=tmpiter->buffer) != NULL)
 385                 {
 386                     const ALubyte *Data = ALBuffer->data;
 387                     ALuint DataSize = ALBuffer->SampleLen;
 388
 389                     /* Skip the data already played */
 390                     if(DataSize <= pos)
 391                         pos -= DataSize;
 392                     else
 393                     {
 394                         Data += pos*FrameSize;
 395                         DataSize -= pos;
 396                         pos -= pos;
 397
 398                         DataSize = minu(BufferSize, DataSize);
 399                         LoadStack(&SrcData[SrcDataSize*NumChannels], Data,
 400                                   ALBuffer->FmtType, DataSize*NumChannels);
 401                         SrcDataSize += DataSize;
 402                         BufferSize -= DataSize;
 403                     }
 404                 }
 405                 tmpiter = tmpiter->next;
 406                 if(!tmpiter && Looping)
 407                     tmpiter = Source->queue;
 408                 else if(!tmpiter)
 409                 {
 410                     SilenceStack(&SrcData[SrcDataSize*NumChannels], BufferSize*NumChannels);
 411                     SrcDataSize += BufferSize;
 412                     BufferSize -= BufferSize;
 413                 }
 414             }
 415         }
 416
 417         /* Figure out how many samples we can mix. */
 418         DataSize64  = SrcDataSize;
 419         DataSize64 -= BufferPadding+BufferPrePadding;
 420         DataSize64 <<= FRACTIONBITS;
 421         DataSize64 -= increment;
 422         DataSize64 -= DataPosFrac;
 423
 424         BufferSize = (ALuint)((DataSize64+(increment-1)) / increment);
 425         BufferSize = minu(BufferSize, (SamplesToDo-OutPos));
 426
 427         SrcData += BufferPrePadding*NumChannels;
 428         for(i = 0;i < NumChannels;i++)
 429         {
 430             ALfloat ResampledData[BUFFERSIZE];
 431
 432             Resample(Resampler, SrcData+i, DataPosFrac, increment,
 433                      NumChannels, ResampledData, BufferSize);
 434
 435             Source->Params.DryMix(Source, Device, &Source->Params.Direct,
 436                                   ResampledData, i, OutPos, SamplesToDo,
 437                                   BufferSize);
 438             for(j = 0;j < Device->NumAuxSends;j++)
 439             {
 440                 if(!Source->Params.Slot[j])
 441                     continue;
 442                 Source->Params.WetMix(Source, j, &Source->Params.Send[j],
 443                                       ResampledData, i, OutPos, SamplesToDo,
 444                                       BufferSize);
 445             }
 446         }
 447         for(i = 0;i < BufferSize;i++)
 448         {
 449             DataPosFrac += increment;
 450             DataPosInt  += DataPosFrac>>FRACTIONBITS;
 451             DataPosFrac &= FRACTIONMASK;
 452             OutPos++;
 453         }
 454
 455         /* Handle looping sources */
 456         while(1)
 457         {
 458             const ALbuffer *ALBuffer;
 459             ALuint DataSize = 0;
 460             ALuint LoopStart = 0;
 461             ALuint LoopEnd = 0;
 462
 463             if((ALBuffer=BufferListItem->buffer) != NULL)
 464             {
 465                 DataSize = ALBuffer->SampleLen;
 466                 LoopStart = ALBuffer->LoopStart;
 467                 LoopEnd = ALBuffer->LoopEnd;
 468                 if(LoopEnd > DataPosInt)
 469                     break;
 470             }
 471
 472             if(Looping && Source->SourceType == AL_STATIC)
 473             {
 474                 DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
 475                 break;
 476             }
 477
 478             if(DataSize > DataPosInt)
 479                 break;
 480
 481             if(BufferListItem->next)
 482             {
 483                 BufferListItem = BufferListItem->next;
 484                 BuffersPlayed++;
 485             }
 486             else if(Looping)
 487             {
 488                 BufferListItem = Source->queue;
 489                 BuffersPlayed = 0;
 490             }
 491             else
 492             {
 493                 State = AL_STOPPED;
 494                 BufferListItem = Source->queue;
 495                 BuffersPlayed = Source->BuffersInQueue;
 496                 DataPosInt = 0;
 497                 DataPosFrac = 0;
 498                 break;
 499             }
 500
 501             DataPosInt -= DataSize;
 502         }
 503     } while(State == AL_PLAYING && OutPos < SamplesToDo);
 504
 505     /* Update source info */
 506     Source->state             = State;
 507     Source->BuffersPlayed     = BuffersPlayed;
 508     Source->position          = DataPosInt;
 509     Source->position_fraction = DataPosFrac;
 510     Source->Hrtf.Offset      += OutPos;
 511     if(State == AL_PLAYING)
 512     {
 513         Source->Hrtf.Counter = maxu(Source->Hrtf.Counter, OutPos) - OutPos;
 514         Source->Hrtf.Moving  = AL_TRUE;
 515     }
 516     else
 517     {
 518         Source->Hrtf.Counter = 0;
 519         Source->Hrtf.Moving  = AL_FALSE;
 520     }
 521 }