Alc/mixer_sse.c

   1 #include "config.h"
   2
   3 #ifdef IN_IDE_PARSER
   4 /* KDevelop's parser won't recognize these defines that get added by the -msse
   5  * switch used to compile this source. Without them, xmmintrin.h fails to
   6  * declare anything. */
   7 #define __MMX__
   8 #define __SSE__
   9 #endif
  10 #include <xmmintrin.h>
  11
  12 #include "AL/al.h"
  13 #include "AL/alc.h"
  14 #include "alMain.h"
  15 #include "alu.h"
  16
  17 #include "alSource.h"
  18 #include "alAuxEffectSlot.h"
  19 #include "mixer_defs.h"
  20
  21
  22 static inline void SetupCoeffs(ALfloat (*restrict OutCoeffs)[2],
  23                                const HrtfParams *hrtfparams,
  24                                ALuint IrSize, ALuint Counter)
  25 {
  26     const __m128 counter4 = _mm_set1_ps((float)Counter);
  27     __m128 coeffs, step4;
  28     ALuint i;
  29
  30     for(i = 0;i < IrSize;i += 2)
  31     {
  32         step4  = _mm_load_ps(&hrtfparams->CoeffStep[i][0]);
  33         coeffs = _mm_load_ps(&hrtfparams->Coeffs[i][0]);
  34         coeffs = _mm_sub_ps(coeffs, _mm_mul_ps(step4, counter4));
  35         _mm_store_ps(&OutCoeffs[i][0], coeffs);
  36     }
  37 }
  38
  39 static inline void ApplyCoeffsStep(ALuint Offset, ALfloat (*restrict Values)[2],
  40                                    const ALuint IrSize,
  41                                    ALfloat (*restrict Coeffs)[2],
  42                                    const ALfloat (*restrict CoeffStep)[2],
  43                                    ALfloat left, ALfloat right)
  44 {
  45     const __m128 lrlr = _mm_setr_ps(left, right, left, right);
  46     __m128 coeffs, deltas, imp0, imp1;
  47     __m128 vals = _mm_setzero_ps();
  48     ALuint i;
  49
  50     if((Offset&1))
  51     {
  52         const ALuint o0 = Offset&HRIR_MASK;
  53         const ALuint o1 = (Offset+IrSize-1)&HRIR_MASK;
  54
  55         coeffs = _mm_load_ps(&Coeffs[0][0]);
  56         deltas = _mm_load_ps(&CoeffStep[0][0]);
  57         vals = _mm_loadl_pi(vals, (__m64*)&Values[o0][0]);
  58         imp0 = _mm_mul_ps(lrlr, coeffs);
  59         coeffs = _mm_add_ps(coeffs, deltas);
  60         vals = _mm_add_ps(imp0, vals);
  61         _mm_store_ps(&Coeffs[0][0], coeffs);
  62         _mm_storel_pi((__m64*)&Values[o0][0], vals);
  63         for(i = 1;i < IrSize-1;i += 2)
  64         {
  65             const ALuint o2 = (Offset+i)&HRIR_MASK;
  66
  67             coeffs = _mm_load_ps(&Coeffs[i+1][0]);
  68             deltas = _mm_load_ps(&CoeffStep[i+1][0]);
  69             vals = _mm_load_ps(&Values[o2][0]);
  70             imp1 = _mm_mul_ps(lrlr, coeffs);
  71             coeffs = _mm_add_ps(coeffs, deltas);
  72             imp0 = _mm_shuffle_ps(imp0, imp1, _MM_SHUFFLE(1, 0, 3, 2));
  73             vals = _mm_add_ps(imp0, vals);
  74             _mm_store_ps(&Coeffs[i+1][0], coeffs);
  75             _mm_store_ps(&Values[o2][0], vals);
  76             imp0 = imp1;
  77         }
  78         vals = _mm_loadl_pi(vals, (__m64*)&Values[o1][0]);
  79         imp0 = _mm_movehl_ps(imp0, imp0);
  80         vals = _mm_add_ps(imp0, vals);
  81         _mm_storel_pi((__m64*)&Values[o1][0], vals);
  82     }
  83     else
  84     {
  85         for(i = 0;i < IrSize;i += 2)
  86         {
  87             const ALuint o = (Offset + i)&HRIR_MASK;
  88
  89             coeffs = _mm_load_ps(&Coeffs[i][0]);
  90             deltas = _mm_load_ps(&CoeffStep[i][0]);
  91             vals = _mm_load_ps(&Values[o][0]);
  92             imp0 = _mm_mul_ps(lrlr, coeffs);
  93             coeffs = _mm_add_ps(coeffs, deltas);
  94             vals = _mm_add_ps(imp0, vals);
  95             _mm_store_ps(&Coeffs[i][0], coeffs);
  96             _mm_store_ps(&Values[o][0], vals);
  97         }
  98     }
  99 }
 100
 101 static inline void ApplyCoeffs(ALuint Offset, ALfloat (*restrict Values)[2],
 102                                const ALuint IrSize,
 103                                ALfloat (*restrict Coeffs)[2],
 104                                ALfloat left, ALfloat right)
 105 {
 106     const __m128 lrlr = _mm_setr_ps(left, right, left, right);
 107     __m128 vals = _mm_setzero_ps();
 108     __m128 coeffs;
 109     ALuint i;
 110
 111     if((Offset&1))
 112     {
 113         const ALuint o0 = Offset&HRIR_MASK;
 114         const ALuint o1 = (Offset+IrSize-1)&HRIR_MASK;
 115         __m128 imp0, imp1;
 116
 117         coeffs = _mm_load_ps(&Coeffs[0][0]);
 118         vals = _mm_loadl_pi(vals, (__m64*)&Values[o0][0]);
 119         imp0 = _mm_mul_ps(lrlr, coeffs);
 120         vals = _mm_add_ps(imp0, vals);
 121         _mm_storel_pi((__m64*)&Values[o0][0], vals);
 122         for(i = 1;i < IrSize-1;i += 2)
 123         {
 124             const ALuint o2 = (Offset+i)&HRIR_MASK;
 125
 126             coeffs = _mm_load_ps(&Coeffs[i+1][0]);
 127             vals = _mm_load_ps(&Values[o2][0]);
 128             imp1 = _mm_mul_ps(lrlr, coeffs);
 129             imp0 = _mm_shuffle_ps(imp0, imp1, _MM_SHUFFLE(1, 0, 3, 2));
 130             vals = _mm_add_ps(imp0, vals);
 131             _mm_store_ps(&Values[o2][0], vals);
 132             imp0 = imp1;
 133         }
 134         vals = _mm_loadl_pi(vals, (__m64*)&Values[o1][0]);
 135         imp0 = _mm_movehl_ps(imp0, imp0);
 136         vals = _mm_add_ps(imp0, vals);
 137         _mm_storel_pi((__m64*)&Values[o1][0], vals);
 138     }
 139     else
 140     {
 141         for(i = 0;i < IrSize;i += 2)
 142         {
 143             const ALuint o = (Offset + i)&HRIR_MASK;
 144
 145             coeffs = _mm_load_ps(&Coeffs[i][0]);
 146             vals = _mm_load_ps(&Values[o][0]);
 147             vals = _mm_add_ps(vals, _mm_mul_ps(lrlr, coeffs));
 148             _mm_store_ps(&Values[o][0], vals);
 149         }
 150     }
 151 }
 152
 153 #define SUFFIX SSE
 154 #include "mixer_inc.c"
 155 #undef SUFFIX
 156
 157
 158 void Mix_SSE(const ALfloat *data, ALuint OutChans, ALfloat (*restrict OutBuffer)[BUFFERSIZE],
 159              MixGains *Gains, ALuint Counter, ALuint OutPos, ALuint BufferSize)
 160 {
 161     ALfloat gain, step;
 162     __m128 gain4, step4;
 163     ALuint c;
 164
 165     for(c = 0;c < OutChans;c++)
 166     {
 167         ALuint pos = 0;
 168         gain = Gains[c].Current;
 169         step = Gains[c].Step;
 170         if(step != 0.0f && Counter > 0)
 171         {
 172             /* Mix with applying gain steps in aligned multiples of 4. */
 173             if(BufferSize-pos > 3 && Counter-pos > 3)
 174             {
 175                 gain4 = _mm_setr_ps(
 176                     gain,
 177                     gain + step,
 178                     gain + step + step,
 179                     gain + step + step + step
 180                 );
 181                 step4 = _mm_set1_ps(step + step + step + step);
 182                 do {
 183                     const __m128 val4 = _mm_load_ps(&data[pos]);
 184                     __m128 dry4 = _mm_load_ps(&OutBuffer[c][OutPos+pos]);
 185                     dry4 = _mm_add_ps(dry4, _mm_mul_ps(val4, gain4));
 186                     gain4 = _mm_add_ps(gain4, step4);
 187                     _mm_store_ps(&OutBuffer[c][OutPos+pos], dry4);
 188                     pos += 4;
 189                 } while(BufferSize-pos > 3 && Counter-pos > 3);
 190                 gain = _mm_cvtss_f32(gain4);
 191             }
 192             /* Mix with applying left over gain steps that aren't aligned multiples of 4. */
 193             for(;pos < BufferSize && pos < Counter;pos++)
 194             {
 195                 OutBuffer[c][OutPos+pos] += data[pos]*gain;
 196                 gain += step;
 197             }
 198             if(pos == Counter)
 199                 gain = Gains[c].Target;
 200             Gains[c].Current = gain;
 201             /* Mix until pos is aligned with 4 or the mix is done. */
 202             for(;pos < BufferSize && (pos&3) != 0;pos++)
 203                 OutBuffer[c][OutPos+pos] += data[pos]*gain;
 204         }
 205
 206         if(!(fabsf(gain) > GAIN_SILENCE_THRESHOLD))
 207             continue;
 208         gain4 = _mm_set1_ps(gain);
 209         for(;BufferSize-pos > 3;pos += 4)
 210         {
 211             const __m128 val4 = _mm_load_ps(&data[pos]);
 212             __m128 dry4 = _mm_load_ps(&OutBuffer[c][OutPos+pos]);
 213             dry4 = _mm_add_ps(dry4, _mm_mul_ps(val4, gain4));
 214             _mm_store_ps(&OutBuffer[c][OutPos+pos], dry4);
 215         }
 216         for(;pos < BufferSize;pos++)
 217             OutBuffer[c][OutPos+pos] += data[pos]*gain;
 218     }
 219 }