Alc/panning.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2010 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 "alAuxEffectSlot.h"
  31 #include "alu.h"
  32 #include "bool.h"
  33
  34
  35 extern inline void CalcXYZCoeffs(ALfloat x, ALfloat y, ALfloat z, ALfloat coeffs[MAX_AMBI_COEFFS]);
  36
  37
  38 #define ZERO_ORDER_SCALE    0.0f
  39 #define FIRST_ORDER_SCALE   1.0f
  40 #define SECOND_ORDER_SCALE  (1.0f / 1.22474f)
  41 #define THIRD_ORDER_SCALE   (1.0f / 1.30657f)
  42
  43
  44 static const ALuint FuMa2ACN[MAX_AMBI_COEFFS] = {
  45     0,  /* W */
  46     3,  /* X */
  47     1,  /* Y */
  48     2,  /* Z */
  49     6,  /* R */
  50     7,  /* S */
  51     5,  /* T */
  52     8,  /* U */
  53     4,  /* V */
  54     12, /* K */
  55     13, /* L */
  56     11, /* M */
  57     14, /* N */
  58     10, /* O */
  59     15, /* P */
  60     9,  /* Q */
  61 };
  62
  63 /* NOTE: These are scale factors as applied to Ambisonics content. FuMa
  64  * decoder coefficients should be divided by these values to get N3D decoder
  65  * coefficients.
  66  */
  67 static const ALfloat FuMa2N3DScale[MAX_AMBI_COEFFS] = {
  68     1.414213562f, /* ACN  0 (W), sqrt(2) */
  69     1.732050808f, /* ACN  1 (Y), sqrt(3) */
  70     1.732050808f, /* ACN  2 (Z), sqrt(3) */
  71     1.732050808f, /* ACN  3 (X), sqrt(3) */
  72     1.936491673f, /* ACN  4 (V), sqrt(15)/2 */
  73     1.936491673f, /* ACN  5 (T), sqrt(15)/2 */
  74     2.236067978f, /* ACN  6 (R), sqrt(5) */
  75     1.936491673f, /* ACN  7 (S), sqrt(15)/2 */
  76     1.936491673f, /* ACN  8 (U), sqrt(15)/2 */
  77     2.091650066f, /* ACN  9 (Q), sqrt(35/8) */
  78     1.972026594f, /* ACN 10 (O), sqrt(35)/3 */
  79     2.231093404f, /* ACN 11 (M), sqrt(224/45) */
  80     2.645751311f, /* ACN 12 (K), sqrt(7) */
  81     2.231093404f, /* ACN 13 (L), sqrt(224/45) */
  82     1.972026594f, /* ACN 14 (N), sqrt(35)/3 */
  83     2.091650066f, /* ACN 15 (P), sqrt(35/8) */
  84 };
  85
  86
  87 void CalcDirectionCoeffs(const ALfloat dir[3], ALfloat coeffs[MAX_AMBI_COEFFS])
  88 {
  89     /* Convert from OpenAL coords to Ambisonics. */
  90     ALfloat x = -dir[2];
  91     ALfloat y = -dir[0];
  92     ALfloat z =  dir[1];
  93
  94     /* Zeroth-order */
  95     coeffs[0]  = 1.0f; /* ACN 0 = 1 */
  96     /* First-order */
  97     coeffs[1]  = 1.732050808f * y; /* ACN 1 = sqrt(3) * Y */
  98     coeffs[2]  = 1.732050808f * z; /* ACN 2 = sqrt(3) * Z */
  99     coeffs[3]  = 1.732050808f * x; /* ACN 3 = sqrt(3) * X */
 100     /* Second-order */
 101     coeffs[4]  = 3.872983346f * x * y;             /* ACN 4 = sqrt(15) * X * Y */
 102     coeffs[5]  = 3.872983346f * y * z;             /* ACN 5 = sqrt(15) * Y * Z */
 103     coeffs[6]  = 1.118033989f * (3.0f*z*z - 1.0f); /* ACN 6 = sqrt(5)/2 * (3*Z*Z - 1) */
 104     coeffs[7]  = 3.872983346f * x * z;             /* ACN 7 = sqrt(15) * X * Z */
 105     coeffs[8]  = 1.936491673f * (x*x - y*y);       /* ACN 8 = sqrt(15)/2 * (X*X - Y*Y) */
 106     /* Third-order */
 107     coeffs[9]  =  2.091650066f * y * (3.0f*x*x - y*y);  /* ACN  9 = sqrt(35/8) * Y * (3*X*X - Y*Y) */
 108     coeffs[10] = 10.246950766f * z * x * y;             /* ACN 10 = sqrt(105) * Z * X * Y */
 109     coeffs[11] =  1.620185175f * y * (5.0f*z*z - 1.0f); /* ACN 11 = sqrt(21/8) * Y * (5*Z*Z - 1) */
 110     coeffs[12] =  1.322875656f * z * (5.0f*z*z - 3.0f); /* ACN 12 = sqrt(7)/2 * Z * (5*Z*Z - 3) */
 111     coeffs[13] =  1.620185175f * x * (5.0f*z*z - 1.0f); /* ACN 13 = sqrt(21/8) * X * (5*Z*Z - 1) */
 112     coeffs[14] =  5.123475383f * z * (x*x - y*y);       /* ACN 14 = sqrt(105)/2 * Z * (X*X - Y*Y) */
 113     coeffs[15] =  2.091650066f * x * (x*x - 3.0f*y*y);  /* ACN 15 = sqrt(35/8) * X * (X*X - 3*Y*Y) */
 114 }
 115
 116 void CalcAngleCoeffs(ALfloat angle, ALfloat elevation, ALfloat coeffs[MAX_AMBI_COEFFS])
 117 {
 118     ALfloat dir[3] = {
 119         sinf(angle) * cosf(elevation),
 120         sinf(elevation),
 121         -cosf(angle) * cosf(elevation)
 122     };
 123     CalcDirectionCoeffs(dir, coeffs);
 124 }
 125
 126
 127 void ComputeAmbientGains(const ChannelConfig *chancoeffs, ALuint numchans, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
 128 {
 129     ALuint i;
 130
 131     for(i = 0;i < numchans;i++)
 132     {
 133         // The W coefficients are based on a mathematical average of the
 134         // output. The square root of the base average provides for a more
 135         // perceptual average volume, better suited to non-directional gains.
 136         gains[i] = sqrtf(chancoeffs[i][0]) * ingain;
 137     }
 138     for(;i < MAX_OUTPUT_CHANNELS;i++)
 139         gains[i] = 0.0f;
 140 }
 141
 142 void ComputePanningGains(const ChannelConfig *chancoeffs, ALuint numchans, const ALfloat coeffs[MAX_AMBI_COEFFS], ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
 143 {
 144     ALuint i, j;
 145
 146     for(i = 0;i < numchans;i++)
 147     {
 148         float gain = 0.0f;
 149         for(j = 0;j < MAX_AMBI_COEFFS;j++)
 150             gain += chancoeffs[i][j]*coeffs[j];
 151         gains[i] = gain * ingain;
 152     }
 153     for(;i < MAX_OUTPUT_CHANNELS;i++)
 154         gains[i] = 0.0f;
 155 }
 156
 157 void ComputeFirstOrderGains(const ChannelConfig *chancoeffs, ALuint numchans, const ALfloat mtx[4], ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
 158 {
 159     ALuint i, j;
 160
 161     for(i = 0;i < numchans;i++)
 162     {
 163         float gain = 0.0f;
 164         for(j = 0;j < 4;j++)
 165             gain += chancoeffs[i][j] * mtx[j];
 166         gains[i] = gain * ingain;
 167     }
 168     for(;i < MAX_OUTPUT_CHANNELS;i++)
 169         gains[i] = 0.0f;
 170 }
 171
 172
 173 DECL_CONST static inline const char *GetLabelFromChannel(enum Channel channel)
 174 {
 175     switch(channel)
 176     {
 177         case FrontLeft: return "front-left";
 178         case FrontRight: return "front-right";
 179         case FrontCenter: return "front-center";
 180         case LFE: return "lfe";
 181         case BackLeft: return "back-left";
 182         case BackRight: return "back-right";
 183         case BackCenter: return "back-center";
 184         case SideLeft: return "side-left";
 185         case SideRight: return "side-right";
 186
 187         case UpperFrontLeft: return "upper-front-left";
 188         case UpperFrontRight: return "upper-front-right";
 189         case UpperBackLeft: return "upper-back-left";
 190         case UpperBackRight: return "upper-back-right";
 191         case LowerFrontLeft: return "lower-front-left";
 192         case LowerFrontRight: return "lower-front-right";
 193         case LowerBackLeft: return "lower-back-left";
 194         case LowerBackRight: return "lower-back-right";
 195
 196         case BFormatW: return "bformat-w";
 197         case BFormatX: return "bformat-x";
 198         case BFormatY: return "bformat-y";
 199         case BFormatZ: return "bformat-z";
 200
 201         case InvalidChannel: break;
 202     }
 203     return "(unknown)";
 204 }
 205
 206
 207 typedef struct ChannelMap {
 208     enum Channel ChanName;
 209     ChannelConfig Config;
 210 } ChannelMap;
 211
 212 static void SetChannelMap(const enum Channel *devchans, ChannelConfig *ambicoeffs,
 213                           const ChannelMap *chanmap, size_t count, ALuint *outcount,
 214                           ALboolean isfuma)
 215 {
 216     size_t j, k;
 217     ALuint i;
 218
 219     for(i = 0;i < MAX_OUTPUT_CHANNELS && devchans[i] != InvalidChannel;i++)
 220     {
 221         if(devchans[i] == LFE)
 222         {
 223             for(j = 0;j < MAX_AMBI_COEFFS;j++)
 224                 ambicoeffs[i][j] = 0.0f;
 225             continue;
 226         }
 227
 228         for(j = 0;j < count;j++)
 229         {
 230             if(devchans[i] != chanmap[j].ChanName)
 231                 continue;
 232
 233             if(isfuma)
 234             {
 235                 /* Reformat FuMa -> ACN/N3D */
 236                 for(k = 0;k < MAX_AMBI_COEFFS;++k)
 237                 {
 238                     ALuint acn = FuMa2ACN[k];
 239                     ambicoeffs[i][acn] = chanmap[j].Config[k] / FuMa2N3DScale[acn];
 240                 }
 241             }
 242             else
 243             {
 244                 for(k = 0;k < MAX_AMBI_COEFFS;++k)
 245                     ambicoeffs[i][k] = chanmap[j].Config[k];
 246             }
 247             break;
 248         }
 249         if(j == count)
 250             ERR("Failed to match %s channel (%u) in channel map\n", GetLabelFromChannel(devchans[i]), i);
 251     }
 252     *outcount = i;
 253 }
 254
 255 static bool LoadChannelSetup(ALCdevice *device)
 256 {
 257     static const enum Channel mono_chans[1] = {
 258         FrontCenter
 259     }, stereo_chans[2] = {
 260         FrontLeft, FrontRight
 261     }, quad_chans[4] = {
 262         FrontLeft, FrontRight,
 263         BackLeft, BackRight
 264     }, surround51_chans[5] = {
 265         FrontLeft, FrontRight, FrontCenter,
 266         SideLeft, SideRight
 267     }, surround51rear_chans[5] = {
 268         FrontLeft, FrontRight, FrontCenter,
 269         BackLeft, BackRight
 270     }, surround61_chans[6] = {
 271         FrontLeft, FrontRight,
 272         FrontCenter, BackCenter,
 273         SideLeft, SideRight
 274     }, surround71_chans[7] = {
 275         FrontLeft, FrontRight, FrontCenter,
 276         BackLeft, BackRight,
 277         SideLeft, SideRight
 278     };
 279     ChannelMap chanmap[MAX_OUTPUT_CHANNELS];
 280     const enum Channel *channels = NULL;
 281     const char *layout = NULL;
 282     ALfloat ambiscale = 1.0f;
 283     size_t count = 0;
 284     int isfuma;
 285     int order;
 286     size_t i;
 287
 288     switch(device->FmtChans)
 289     {
 290         case DevFmtMono:
 291             layout = "mono";
 292             channels = mono_chans;
 293             count = COUNTOF(mono_chans);
 294             break;
 295         case DevFmtStereo:
 296             layout = "stereo";
 297             channels = stereo_chans;
 298             count = COUNTOF(stereo_chans);
 299             break;
 300         case DevFmtQuad:
 301             layout = "quad";
 302             channels = quad_chans;
 303             count = COUNTOF(quad_chans);
 304             break;
 305         case DevFmtX51:
 306             layout = "surround51";
 307             channels = surround51_chans;
 308             count = COUNTOF(surround51_chans);
 309             break;
 310         case DevFmtX51Rear:
 311             layout = "surround51rear";
 312             channels = surround51rear_chans;
 313             count = COUNTOF(surround51rear_chans);
 314             break;
 315         case DevFmtX61:
 316             layout = "surround61";
 317             channels = surround61_chans;
 318             count = COUNTOF(surround61_chans);
 319             break;
 320         case DevFmtX71:
 321             layout = "surround71";
 322             channels = surround71_chans;
 323             count = COUNTOF(surround71_chans);
 324             break;
 325         case DevFmtBFormat3D:
 326             break;
 327     }
 328
 329     if(!layout)
 330         return false;
 331     else
 332     {
 333         char name[32] = {0};
 334         const char *type;
 335         char eol;
 336
 337         snprintf(name, sizeof(name), "%s/type", layout);
 338         if(!ConfigValueStr(al_string_get_cstr(device->DeviceName), "layouts", name, &type))
 339             return false;
 340
 341         if(sscanf(type, " %31[^: ] : %d%c", name, &order, &eol) != 2)
 342         {
 343             ERR("Invalid type value '%s' (expected name:order) for layout %s\n", type, layout);
 344             return false;
 345         }
 346
 347         if(strcasecmp(name, "fuma") == 0)
 348             isfuma = 1;
 349         else if(strcasecmp(name, "n3d") == 0)
 350             isfuma = 0;
 351         else
 352         {
 353             ERR("Unhandled type name '%s' (expected FuMa or N3D) for layout %s\n", name, layout);
 354             return false;
 355         }
 356
 357         if(order == 3)
 358             ambiscale = THIRD_ORDER_SCALE;
 359         else if(order == 2)
 360             ambiscale = SECOND_ORDER_SCALE;
 361         else if(order == 1)
 362             ambiscale = FIRST_ORDER_SCALE;
 363         else if(order == 0)
 364             ambiscale = ZERO_ORDER_SCALE;
 365         else
 366         {
 367             ERR("Unhandled type order %d (expected 0, 1, 2, or 3) for layout %s\n", order, layout);
 368             return false;
 369         }
 370     }
 371
 372     for(i = 0;i < count;i++)
 373     {
 374         float coeffs[MAX_AMBI_COEFFS] = {0.0f};
 375         const char *channame;
 376         char chanlayout[32];
 377         const char *value;
 378         int props = 0;
 379         char eol = 0;
 380         int j;
 381
 382         chanmap[i].ChanName = channels[i];
 383         channame = GetLabelFromChannel(channels[i]);
 384
 385         snprintf(chanlayout, sizeof(chanlayout), "%s/%s", layout, channame);
 386         if(!ConfigValueStr(al_string_get_cstr(device->DeviceName), "layouts", chanlayout, &value))
 387         {
 388             ERR("Missing channel %s\n", channame);
 389             return false;
 390         }
 391         if(order == 3)
 392             props = sscanf(value, " %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %c",
 393                 &coeffs[0],  &coeffs[1],  &coeffs[2],  &coeffs[3],
 394                 &coeffs[4],  &coeffs[5],  &coeffs[6],  &coeffs[7],
 395                 &coeffs[8],  &coeffs[9],  &coeffs[10], &coeffs[11],
 396                 &coeffs[12], &coeffs[13], &coeffs[14], &coeffs[15],
 397                 &eol
 398             );
 399         else if(order == 2)
 400             props = sscanf(value, " %f %f %f %f %f %f %f %f %f %c",
 401                 &coeffs[0], &coeffs[1], &coeffs[2],
 402                 &coeffs[3], &coeffs[4], &coeffs[5],
 403                 &coeffs[6], &coeffs[7], &coeffs[8],
 404                 &eol
 405             );
 406         else if(order == 1)
 407             props = sscanf(value, " %f %f %f %f %c",
 408                 &coeffs[0], &coeffs[1],
 409                 &coeffs[2], &coeffs[3],
 410                 &eol
 411             );
 412         else if(order == 0)
 413             props = sscanf(value, " %f %c", &coeffs[0], &eol);
 414         if(props == 0)
 415         {
 416             ERR("Failed to parse option %s properties\n", chanlayout);
 417             return false;
 418         }
 419
 420         if(props > (order+1)*(order+1))
 421         {
 422             ERR("Excess elements in option %s (expected %d)\n", chanlayout, (order+1)*(order+1));
 423             return false;
 424         }
 425
 426         for(j = 0;j < MAX_AMBI_COEFFS;++j)
 427             chanmap[i].Config[j] = coeffs[j];
 428     }
 429     SetChannelMap(device->Dry.ChannelName, device->Dry.AmbiCoeffs, chanmap, count,
 430                   &device->Dry.NumChannels, isfuma);
 431     device->Dry.AmbiScale = ambiscale;
 432     return true;
 433 }
 434
 435 ALvoid aluInitPanning(ALCdevice *device)
 436 {
 437     /* NOTE: These decoder coefficients are using FuMa channel ordering and
 438      * normalization, since that's what was produced by the Ambisonic Decoder
 439      * Toolbox. SetChannelMap will convert them to N3D.
 440      */
 441     static const ChannelMap MonoCfg[1] = {
 442         { FrontCenter, { 1.414213562f } },
 443     }, StereoCfg[2] = {
 444         { FrontLeft,   { 0.707106781f, 0.0f,  0.5f, 0.0f } },
 445         { FrontRight,  { 0.707106781f, 0.0f, -0.5f, 0.0f } },
 446     }, QuadCfg[4] = {
 447         { FrontLeft,   { 0.353553f,  0.306184f,  0.306184f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f,  0.117186f } },
 448         { FrontRight,  { 0.353553f,  0.306184f, -0.306184f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f, -0.117186f } },
 449         { BackLeft,    { 0.353553f, -0.306184f,  0.306184f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f, -0.117186f } },
 450         { BackRight,   { 0.353553f, -0.306184f, -0.306184f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f,  0.117186f } },
 451     }, X51SideCfg[5] = {
 452         { FrontLeft,   { 0.208954f,  0.212846f,  0.238350f, 0.0f, 0.0f, 0.0f, 0.0f, -0.017738f,  0.204014f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.051023f,  0.047490f } },
 453         { FrontRight,  { 0.208954f,  0.212846f, -0.238350f, 0.0f, 0.0f, 0.0f, 0.0f, -0.017738f, -0.204014f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.051023f, -0.047490f } },
 454         { FrontCenter, { 0.109403f,  0.179490f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f,  0.142031f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.072024f,  0.000000f } },
 455         { SideLeft,    { 0.470936f, -0.369626f,  0.349386f, 0.0f, 0.0f, 0.0f, 0.0f, -0.031375f, -0.058144f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.007119f, -0.043968f } },
 456         { SideRight,   { 0.470936f, -0.369626f, -0.349386f, 0.0f, 0.0f, 0.0f, 0.0f, -0.031375f,  0.058144f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.007119f,  0.043968f } },
 457     }, X51RearCfg[5] = {
 458         { FrontLeft,   { 0.208954f,  0.212846f,  0.238350f, 0.0f, 0.0f, 0.0f, 0.0f, -0.017738f,  0.204014f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.051023f,  0.047490f } },
 459         { FrontRight,  { 0.208954f,  0.212846f, -0.238350f, 0.0f, 0.0f, 0.0f, 0.0f, -0.017738f, -0.204014f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.051023f, -0.047490f } },
 460         { FrontCenter, { 0.109403f,  0.179490f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f,  0.142031f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.072024f,  0.000000f } },
 461         { BackLeft,    { 0.470936f, -0.369626f,  0.349386f, 0.0f, 0.0f, 0.0f, 0.0f, -0.031375f, -0.058144f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.007119f, -0.043968f } },
 462         { BackRight,   { 0.470936f, -0.369626f, -0.349386f, 0.0f, 0.0f, 0.0f, 0.0f, -0.031375f,  0.058144f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.007119f,  0.043968f } },
 463     }, X61Cfg[6] = {
 464         { FrontLeft,   { 0.167065f,  0.200583f,  0.172695f, 0.0f, 0.0f, 0.0f, 0.0f,  0.029855f,  0.186407f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.039241f,  0.068910f } },
 465         { FrontRight,  { 0.167065f,  0.200583f, -0.172695f, 0.0f, 0.0f, 0.0f, 0.0f,  0.029855f, -0.186407f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.039241f, -0.068910f } },
 466         { FrontCenter, { 0.109403f,  0.179490f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f,  0.142031f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.072024f,  0.000000f } },
 467         { BackCenter,  { 0.353556f, -0.461940f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f,  0.165723f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f,  0.000000f } },
 468         { SideLeft,    { 0.289151f, -0.081301f,  0.401292f, 0.0f, 0.0f, 0.0f, 0.0f, -0.188208f, -0.071420f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.010099f, -0.032897f } },
 469         { SideRight,   { 0.289151f, -0.081301f, -0.401292f, 0.0f, 0.0f, 0.0f, 0.0f, -0.188208f,  0.071420f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.010099f,  0.032897f } },
 470     }, X71Cfg[7] = {
 471         { FrontLeft,   { 0.167065f,  0.200583f,  0.172695f, 0.0f, 0.0f, 0.0f, 0.0f,  0.029855f,  0.186407f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.039241f,  0.068910f } },
 472         { FrontRight,  { 0.167065f,  0.200583f, -0.172695f, 0.0f, 0.0f, 0.0f, 0.0f,  0.029855f, -0.186407f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, -0.039241f, -0.068910f } },
 473         { FrontCenter, { 0.109403f,  0.179490f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f,  0.142031f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.072024f,  0.000000f } },
 474         { BackLeft,    { 0.224752f, -0.295009f,  0.170325f, 0.0f, 0.0f, 0.0f, 0.0f,  0.105349f, -0.182473f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f,  0.065799f } },
 475         { BackRight,   { 0.224752f, -0.295009f, -0.170325f, 0.0f, 0.0f, 0.0f, 0.0f,  0.105349f,  0.182473f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f, -0.065799f } },
 476         { SideLeft,    { 0.224739f,  0.000000f,  0.340644f, 0.0f, 0.0f, 0.0f, 0.0f, -0.210697f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f, -0.065795f } },
 477         { SideRight,   { 0.224739f,  0.000000f, -0.340644f, 0.0f, 0.0f, 0.0f, 0.0f, -0.210697f,  0.000000f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,  0.000000f,  0.065795f } },
 478     }, Cube8Cfg[8] = {
 479         { UpperFrontLeft,  { 0.176776695f,  0.072168784f,  0.072168784f,  0.072168784f } },
 480         { UpperFrontRight, { 0.176776695f,  0.072168784f, -0.072168784f,  0.072168784f } },
 481         { UpperBackLeft,   { 0.176776695f, -0.072168784f,  0.072168784f,  0.072168784f } },
 482         { UpperBackRight,  { 0.176776695f, -0.072168784f, -0.072168784f,  0.072168784f } },
 483         { LowerFrontLeft,  { 0.176776695f,  0.072168784f,  0.072168784f, -0.072168784f } },
 484         { LowerFrontRight, { 0.176776695f,  0.072168784f, -0.072168784f, -0.072168784f } },
 485         { LowerBackLeft,   { 0.176776695f, -0.072168784f,  0.072168784f, -0.072168784f } },
 486         { LowerBackRight,  { 0.176776695f, -0.072168784f, -0.072168784f, -0.072168784f } },
 487     }, BFormat2D[3] = {
 488         { BFormatW, { 1.0f, 0.0f, 0.0f, 0.0f } },
 489         { BFormatX, { 0.0f, 1.0f, 0.0f, 0.0f } },
 490         { BFormatY, { 0.0f, 0.0f, 1.0f, 0.0f } },
 491     }, BFormat3D[4] = {
 492         { BFormatW, { 1.0f, 0.0f, 0.0f, 0.0f } },
 493         { BFormatX, { 0.0f, 1.0f, 0.0f, 0.0f } },
 494         { BFormatY, { 0.0f, 0.0f, 1.0f, 0.0f } },
 495         { BFormatZ, { 0.0f, 0.0f, 0.0f, 1.0f } },
 496     };
 497     const ChannelMap *chanmap = NULL;
 498     ALfloat ambiscale = 1.0f;
 499     size_t count = 0;
 500     ALuint i;
 501
 502     device->Dry.AmbiScale = 1.0f;
 503     memset(device->Dry.AmbiCoeffs, 0, sizeof(device->Dry.AmbiCoeffs));
 504     device->Dry.NumChannels = 0;
 505
 506     if(device->Hrtf)
 507     {
 508         static const struct {
 509             enum Channel Channel;
 510             ALfloat Angle;
 511             ALfloat Elevation;
 512         } CubeInfo[8] = {
 513             { UpperFrontLeft,  DEG2RAD( -45.0f), DEG2RAD( 45.0f) },
 514             { UpperFrontRight, DEG2RAD(  45.0f), DEG2RAD( 45.0f) },
 515             { UpperBackLeft,   DEG2RAD(-135.0f), DEG2RAD( 45.0f) },
 516             { UpperBackRight,  DEG2RAD( 135.0f), DEG2RAD( 45.0f) },
 517             { LowerFrontLeft,  DEG2RAD( -45.0f), DEG2RAD(-45.0f) },
 518             { LowerFrontRight, DEG2RAD(  45.0f), DEG2RAD(-45.0f) },
 519             { LowerBackLeft,   DEG2RAD(-135.0f), DEG2RAD(-45.0f) },
 520             { LowerBackRight,  DEG2RAD( 135.0f), DEG2RAD(-45.0f) },
 521         };
 522
 523         count = COUNTOF(Cube8Cfg);
 524         chanmap = Cube8Cfg;
 525         ambiscale = FIRST_ORDER_SCALE;
 526
 527         for(i = 0;i < count;i++)
 528             device->Dry.ChannelName[i] = chanmap[i].ChanName;
 529         for(;i < MAX_OUTPUT_CHANNELS;i++)
 530             device->Dry.ChannelName[i] = InvalidChannel;
 531         SetChannelMap(device->Dry.ChannelName, device->Dry.AmbiCoeffs, chanmap, count,
 532                       &device->Dry.NumChannels, AL_TRUE);
 533         device->Dry.AmbiScale = ambiscale;
 534
 535         for(i = 0;i < device->Dry.NumChannels;i++)
 536         {
 537             int chan = GetChannelIdxByName(device, CubeInfo[i].Channel);
 538             GetLerpedHrtfCoeffs(device->Hrtf, CubeInfo[i].Elevation, CubeInfo[i].Angle, 1.0f, 1.0f,
 539                                 device->Hrtf_Params[chan].Coeffs, device->Hrtf_Params[chan].Delay);
 540         }
 541         return;
 542     }
 543     if(device->Uhj_Encoder)
 544     {
 545         count = COUNTOF(BFormat2D);
 546         chanmap = BFormat2D;
 547         ambiscale = FIRST_ORDER_SCALE;
 548
 549         for(i = 0;i < count;i++)
 550             device->Dry.ChannelName[i] = chanmap[i].ChanName;
 551         for(;i < MAX_OUTPUT_CHANNELS;i++)
 552             device->Dry.ChannelName[i] = InvalidChannel;
 553         SetChannelMap(device->Dry.ChannelName, device->Dry.AmbiCoeffs, chanmap, count,
 554                       &device->Dry.NumChannels, AL_TRUE);
 555         device->Dry.AmbiScale = ambiscale;
 556
 557         return;
 558     }
 559
 560     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 561         device->Dry.ChannelName[i] = device->RealOut.ChannelName[i];
 562
 563     if(LoadChannelSetup(device))
 564         return;
 565
 566     switch(device->FmtChans)
 567     {
 568         case DevFmtMono:
 569             count = COUNTOF(MonoCfg);
 570             chanmap = MonoCfg;
 571             ambiscale = ZERO_ORDER_SCALE;
 572             break;
 573
 574         case DevFmtStereo:
 575             count = COUNTOF(StereoCfg);
 576             chanmap = StereoCfg;
 577             ambiscale = FIRST_ORDER_SCALE;
 578             break;
 579
 580         case DevFmtQuad:
 581             count = COUNTOF(QuadCfg);
 582             chanmap = QuadCfg;
 583             ambiscale = SECOND_ORDER_SCALE;
 584             break;
 585
 586         case DevFmtX51:
 587             count = COUNTOF(X51SideCfg);
 588             chanmap = X51SideCfg;
 589             ambiscale = THIRD_ORDER_SCALE;
 590             break;
 591
 592         case DevFmtX51Rear:
 593             count = COUNTOF(X51RearCfg);
 594             chanmap = X51RearCfg;
 595             ambiscale = THIRD_ORDER_SCALE;
 596             break;
 597
 598         case DevFmtX61:
 599             count = COUNTOF(X61Cfg);
 600             chanmap = X61Cfg;
 601             ambiscale = THIRD_ORDER_SCALE;
 602             break;
 603
 604         case DevFmtX71:
 605             count = COUNTOF(X71Cfg);
 606             chanmap = X71Cfg;
 607             ambiscale = THIRD_ORDER_SCALE;
 608             break;
 609
 610         case DevFmtBFormat3D:
 611             count = COUNTOF(BFormat3D);
 612             chanmap = BFormat3D;
 613             ambiscale = 1.0f;
 614             break;
 615     }
 616
 617     SetChannelMap(device->Dry.ChannelName, device->Dry.AmbiCoeffs, chanmap, count,
 618                   &device->Dry.NumChannels, AL_TRUE);
 619     device->Dry.AmbiScale = ambiscale;
 620 }
 621
 622 void aluInitEffectPanning(ALeffectslot *slot)
 623 {
 624     static const ChannelMap FirstOrderN3D[4] = {
 625         { BFormatW, { 1.0f, 0.0f, 0.0f, 0.0f } },
 626         { BFormatY, { 0.0f, 1.0f, 0.0f, 0.0f } },
 627         { BFormatZ, { 0.0f, 0.0f, 1.0f, 0.0f } },
 628         { BFormatX, { 0.0f, 0.0f, 0.0f, 1.0f } },
 629     };
 630     static const enum Channel AmbiChannels[MAX_OUTPUT_CHANNELS] = {
 631         BFormatW, BFormatY, BFormatZ, BFormatX, InvalidChannel
 632     };
 633
 634     memset(slot->AmbiCoeffs, 0, sizeof(slot->AmbiCoeffs));
 635     slot->NumChannels = 0;
 636
 637     SetChannelMap(AmbiChannels, slot->AmbiCoeffs, FirstOrderN3D, COUNTOF(FirstOrderN3D),
 638                   &slot->NumChannels, AL_FALSE);
 639 }