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 Sample_ALbyte(ALbyte val)
  41 { return val * (1.0f/127.0f); }
  42
  43 static inline ALfloat Sample_ALshort(ALshort val)
  44 { return val * (1.0f/32767.0f); }
  45
  46 static inline ALfloat Sample_ALfloat(ALfloat val)
  47 { return val; }
  48
  49 #define DECL_TEMPLATE(T)                                                      \
  50 static void Load_##T(ALfloat *dst, const T *src, ALuint srcstep, ALuint samples)\
  51 {                                                                             \
  52     ALuint i;                                                                 \
  53     for(i = 0;i < samples;i++)                                                \
  54         dst[i] = Sample_##T(src[i*srcstep]);                                  \
  55 }
  56
  57 DECL_TEMPLATE(ALbyte)
  58 DECL_TEMPLATE(ALshort)
  59 DECL_TEMPLATE(ALfloat)
  60
  61 #undef DECL_TEMPLATE
  62
  63 static void LoadData(ALfloat *dst, const ALvoid *src, ALuint srcstep, enum FmtType srctype, ALuint samples)
  64 {
  65     switch(srctype)
  66     {
  67         case FmtByte:
  68             Load_ALbyte(dst, src, srcstep, samples);
  69             break;
  70         case FmtShort:
  71             Load_ALshort(dst, src, srcstep, samples);
  72             break;
  73         case FmtFloat:
  74             Load_ALfloat(dst, src, srcstep, samples);
  75             break;
  76     }
  77 }
  78
  79 static void SilenceData(ALfloat *dst, ALuint samples)
  80 {
  81     ALuint i;
  82     for(i = 0;i < samples;i++)
  83         dst[i] = 0.0f;
  84 }
  85
  86
  87 static void DoFilter(ALfilterState *filter, ALfloat *restrict dst, const ALfloat *restrict src,
  88                      ALuint numsamples)
  89 {
  90     ALuint i;
  91     for(i = 0;i < numsamples;i++)
  92         dst[i] = ALfilterState_processSingle(filter, src[i]);
  93 }
  94
  95
  96 ALvoid MixSource(ALactivesource *src, ALCdevice *Device, ALuint SamplesToDo)
  97 {
  98     ALsource *Source = src->Source;
  99     ALbufferlistitem *BufferListItem;
 100     ALuint DataPosInt, DataPosFrac;
 101     ALuint BuffersPlayed;
 102     ALboolean Looping;
 103     ALuint increment;
 104     enum Resampler Resampler;
 105     ALenum State;
 106     ALuint OutPos;
 107     ALuint NumChannels;
 108     ALuint SampleSize;
 109     ALint64 DataSize64;
 110     ALuint chan, j;
 111
 112     /* Get source info */
 113     State         = Source->state;
 114     BuffersPlayed = Source->BuffersPlayed;
 115     DataPosInt    = Source->position;
 116     DataPosFrac   = Source->position_fraction;
 117     Looping       = Source->Looping;
 118     increment     = src->Step;
 119     Resampler     = (increment==FRACTIONONE) ? PointResampler : Source->Resampler;
 120     NumChannels   = Source->NumChannels;
 121     SampleSize    = Source->SampleSize;
 122
 123     /* Get current buffer queue item */
 124     BufferListItem = Source->queue;
 125     for(j = 0;j < BuffersPlayed;j++)
 126         BufferListItem = BufferListItem->next;
 127
 128     OutPos = 0;
 129     do {
 130         const ALuint BufferPrePadding = ResamplerPrePadding[Resampler];
 131         const ALuint BufferPadding = ResamplerPadding[Resampler];
 132         ALuint SrcBufferSize, DstBufferSize;
 133
 134         /* Figure out how many buffer samples will be needed */
 135         DataSize64  = SamplesToDo-OutPos;
 136         DataSize64 *= increment;
 137         DataSize64 += DataPosFrac+FRACTIONMASK;
 138         DataSize64 >>= FRACTIONBITS;
 139         DataSize64 += BufferPadding+BufferPrePadding;
 140
 141         SrcBufferSize = (ALuint)mini64(DataSize64, BUFFERSIZE);
 142
 143         /* Figure out how many samples we can actually mix from this. */
 144         DataSize64  = SrcBufferSize;
 145         DataSize64 -= BufferPadding+BufferPrePadding;
 146         DataSize64 <<= FRACTIONBITS;
 147         DataSize64 -= DataPosFrac;
 148
 149         DstBufferSize = (ALuint)((DataSize64+(increment-1)) / increment);
 150         DstBufferSize = minu(DstBufferSize, (SamplesToDo-OutPos));
 151
 152         /* Some mixers like having a multiple of 4, so try to give that unless
 153          * this is the last update. */
 154         if(OutPos+DstBufferSize < SamplesToDo)
 155             DstBufferSize &= ~3;
 156
 157         for(chan = 0;chan < NumChannels;chan++)
 158         {
 159             ALfloat *SrcData = Device->SampleData1;
 160             ALfloat *ResampledData = Device->SampleData2;
 161             ALuint SrcDataSize = 0;
 162
 163             if(Source->SourceType == AL_STATIC)
 164             {
 165                 const ALbuffer *ALBuffer = Source->queue->buffer;
 166                 const ALubyte *Data = ALBuffer->data;
 167                 ALuint DataSize;
 168                 ALuint pos;
 169
 170                 /* If current pos is beyond the loop range, do not loop */
 171                 if(Looping == AL_FALSE || DataPosInt >= (ALuint)ALBuffer->LoopEnd)
 172                 {
 173                     Looping = AL_FALSE;
 174
 175                     if(DataPosInt >= BufferPrePadding)
 176                         pos = DataPosInt - BufferPrePadding;
 177                     else
 178                     {
 179                         DataSize = BufferPrePadding - DataPosInt;
 180                         DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
 181
 182                         SilenceData(&SrcData[SrcDataSize], DataSize);
 183                         SrcDataSize += DataSize;
 184
 185                         pos = 0;
 186                     }
 187
 188                     /* Copy what's left to play in the source buffer, and clear the
 189                      * rest of the temp buffer */
 190                     DataSize = minu(SrcBufferSize - SrcDataSize, ALBuffer->SampleLen - pos);
 191
 192                     LoadData(&SrcData[SrcDataSize], &Data[(pos*NumChannels + chan)*SampleSize],
 193                              NumChannels, ALBuffer->FmtType, DataSize);
 194                     SrcDataSize += DataSize;
 195
 196                     SilenceData(&SrcData[SrcDataSize], SrcBufferSize - SrcDataSize);
 197                     SrcDataSize += SrcBufferSize - SrcDataSize;
 198                 }
 199                 else
 200                 {
 201                     ALuint LoopStart = ALBuffer->LoopStart;
 202                     ALuint LoopEnd   = ALBuffer->LoopEnd;
 203
 204                     if(DataPosInt >= LoopStart)
 205                     {
 206                         pos = DataPosInt-LoopStart;
 207                         while(pos < BufferPrePadding)
 208                             pos += LoopEnd-LoopStart;
 209                         pos -= BufferPrePadding;
 210                         pos += LoopStart;
 211                     }
 212                     else if(DataPosInt >= BufferPrePadding)
 213                         pos = DataPosInt - BufferPrePadding;
 214                     else
 215                     {
 216                         DataSize = BufferPrePadding - DataPosInt;
 217                         DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
 218
 219                         SilenceData(&SrcData[SrcDataSize], DataSize);
 220                         SrcDataSize += DataSize;
 221
 222                         pos = 0;
 223                     }
 224
 225                     /* Copy what's left of this loop iteration, then copy repeats
 226                      * of the loop section */
 227                     DataSize = LoopEnd - pos;
 228                     DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
 229
 230                     LoadData(&SrcData[SrcDataSize], &Data[(pos*NumChannels + chan)*SampleSize],
 231                              NumChannels, ALBuffer->FmtType, DataSize);
 232                     SrcDataSize += DataSize;
 233
 234                     DataSize = LoopEnd-LoopStart;
 235                     while(SrcBufferSize > SrcDataSize)
 236                     {
 237                         DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
 238
 239                         LoadData(&SrcData[SrcDataSize], &Data[(LoopStart*NumChannels + chan)*SampleSize],
 240                                  NumChannels, ALBuffer->FmtType, DataSize);
 241                         SrcDataSize += DataSize;
 242                     }
 243                 }
 244             }
 245             else
 246             {
 247                 /* Crawl the buffer queue to fill in the temp buffer */
 248                 ALbufferlistitem *tmpiter = BufferListItem;
 249                 ALuint pos;
 250
 251                 if(DataPosInt >= BufferPrePadding)
 252                     pos = DataPosInt - BufferPrePadding;
 253                 else
 254                 {
 255                     pos = BufferPrePadding - DataPosInt;
 256                     while(pos > 0)
 257                     {
 258                         if(!tmpiter->prev && !Looping)
 259                         {
 260                             ALuint DataSize = minu(SrcBufferSize - SrcDataSize, pos);
 261
 262                             SilenceData(&SrcData[SrcDataSize], DataSize);
 263                             SrcDataSize += DataSize;
 264
 265                             pos = 0;
 266                             break;
 267                         }
 268
 269                         if(tmpiter->prev)
 270                             tmpiter = tmpiter->prev;
 271                         else
 272                         {
 273                             while(tmpiter->next)
 274                                 tmpiter = tmpiter->next;
 275                         }
 276
 277                         if(tmpiter->buffer)
 278                         {
 279                             if((ALuint)tmpiter->buffer->SampleLen > pos)
 280                             {
 281                                 pos = tmpiter->buffer->SampleLen - pos;
 282                                 break;
 283                             }
 284                             pos -= tmpiter->buffer->SampleLen;
 285                         }
 286                     }
 287                 }
 288
 289                 while(tmpiter && SrcBufferSize > SrcDataSize)
 290                 {
 291                     const ALbuffer *ALBuffer;
 292                     if((ALBuffer=tmpiter->buffer) != NULL)
 293                     {
 294                         const ALubyte *Data = ALBuffer->data;
 295                         ALuint DataSize = ALBuffer->SampleLen;
 296
 297                         /* Skip the data already played */
 298                         if(DataSize <= pos)
 299                             pos -= DataSize;
 300                         else
 301                         {
 302                             Data += (pos*NumChannels + chan)*SampleSize;
 303                             DataSize -= pos;
 304                             pos -= pos;
 305
 306                             DataSize = minu(SrcBufferSize - SrcDataSize, DataSize);
 307                             LoadData(&SrcData[SrcDataSize], Data, NumChannels,
 308                                      ALBuffer->FmtType, DataSize);
 309                             SrcDataSize += DataSize;
 310                         }
 311                     }
 312                     tmpiter = tmpiter->next;
 313                     if(!tmpiter && Looping)
 314                         tmpiter = Source->queue;
 315                     else if(!tmpiter)
 316                     {
 317                         SilenceData(&SrcData[SrcDataSize], SrcBufferSize - SrcDataSize);
 318                         SrcDataSize += SrcBufferSize - SrcDataSize;
 319                     }
 320                 }
 321             }
 322
 323             /* Now resample, then filter and mix to the appropriate outputs. */
 324             src->Resample(&SrcData[BufferPrePadding], DataPosFrac,
 325                           increment, ResampledData, DstBufferSize);
 326
 327             {
 328                 DirectParams *directparms = &src->Direct;
 329
 330                 DoFilter(&directparms->LpFilter[chan], SrcData, ResampledData,
 331                          DstBufferSize);
 332                 src->DryMix(directparms, SrcData, chan, OutPos, DstBufferSize);
 333             }
 334
 335             for(j = 0;j < Device->NumAuxSends;j++)
 336             {
 337                 SendParams *sendparms = &src->Send[j];
 338                 if(!sendparms->OutBuffer)
 339                     continue;
 340
 341                 DoFilter(&sendparms->LpFilter[chan], SrcData, ResampledData,
 342                          DstBufferSize);
 343                 src->WetMix(sendparms, SrcData, OutPos, DstBufferSize);
 344             }
 345         }
 346         /* Update positions */
 347         for(j = 0;j < DstBufferSize;j++)
 348         {
 349             DataPosFrac += increment;
 350             DataPosInt  += DataPosFrac>>FRACTIONBITS;
 351             DataPosFrac &= FRACTIONMASK;
 352         }
 353         OutPos += DstBufferSize;
 354
 355         /* Handle looping sources */
 356         while(1)
 357         {
 358             const ALbuffer *ALBuffer;
 359             ALuint DataSize = 0;
 360             ALuint LoopStart = 0;
 361             ALuint LoopEnd = 0;
 362
 363             if((ALBuffer=BufferListItem->buffer) != NULL)
 364             {
 365                 DataSize = ALBuffer->SampleLen;
 366                 LoopStart = ALBuffer->LoopStart;
 367                 LoopEnd = ALBuffer->LoopEnd;
 368                 if(LoopEnd > DataPosInt)
 369                     break;
 370             }
 371
 372             if(Looping && Source->SourceType == AL_STATIC)
 373             {
 374                 DataPosInt = ((DataPosInt-LoopStart)%(LoopEnd-LoopStart)) + LoopStart;
 375                 break;
 376             }
 377
 378             if(DataSize > DataPosInt)
 379                 break;
 380
 381             if(BufferListItem->next)
 382             {
 383                 BufferListItem = BufferListItem->next;
 384                 BuffersPlayed++;
 385             }
 386             else if(Looping)
 387             {
 388                 BufferListItem = Source->queue;
 389                 BuffersPlayed = 0;
 390             }
 391             else
 392             {
 393                 State = AL_STOPPED;
 394                 BufferListItem = Source->queue;
 395                 BuffersPlayed = Source->BuffersInQueue;
 396                 DataPosInt = 0;
 397                 DataPosFrac = 0;
 398                 break;
 399             }
 400
 401             DataPosInt -= DataSize;
 402         }
 403     } while(State == AL_PLAYING && OutPos < SamplesToDo);
 404
 405     /* Update source info */
 406     Source->state             = State;
 407     Source->BuffersPlayed     = BuffersPlayed;
 408     Source->position          = DataPosInt;
 409     Source->position_fraction = DataPosFrac;
 410     src->Direct.Offset += OutPos;
 411     src->Direct.Counter = maxu(src->Direct.Counter, OutPos) - OutPos;
 412 }