Alc/bformatdec.c

   1
   2 #include "config.h"
   3
   4 #include "bformatdec.h"
   5 #include "ambdec.h"
   6 #include "mixer_defs.h"
   7 #include "alu.h"
   8
   9 #include "bool.h"
  10 #include "threads.h"
  11 #include "almalloc.h"
  12
  13
  14 void bandsplit_init(BandSplitter *splitter, ALfloat f0norm)
  15 {
  16     ALfloat w = f0norm * F_TAU;
  17     ALfloat cw = cosf(w);
  18     if(cw > FLT_EPSILON)
  19         splitter->coeff = (sinf(w) - 1.0f) / cw;
  20     else
  21         splitter->coeff = cw * -0.5f;
  22
  23     splitter->lp_z1 = 0.0f;
  24     splitter->lp_z2 = 0.0f;
  25     splitter->hp_z1 = 0.0f;
  26 }
  27
  28 void bandsplit_clear(BandSplitter *splitter)
  29 {
  30     splitter->lp_z1 = 0.0f;
  31     splitter->lp_z2 = 0.0f;
  32     splitter->hp_z1 = 0.0f;
  33 }
  34
  35 void bandsplit_process(BandSplitter *splitter, ALfloat *restrict hpout, ALfloat *restrict lpout,
  36                        const ALfloat *input, ALsizei count)
  37 {
  38     ALfloat coeff, d, x;
  39     ALfloat z1, z2;
  40     ALsizei i;
  41
  42     coeff = splitter->coeff*0.5f + 0.5f;
  43     z1 = splitter->lp_z1;
  44     z2 = splitter->lp_z2;
  45     for(i = 0;i < count;i++)
  46     {
  47         x = input[i];
  48
  49         d = (x - z1) * coeff;
  50         x = z1 + d;
  51         z1 = x + d;
  52
  53         d = (x - z2) * coeff;
  54         x = z2 + d;
  55         z2 = x + d;
  56
  57         lpout[i] = x;
  58     }
  59     splitter->lp_z1 = z1;
  60     splitter->lp_z2 = z2;
  61
  62     coeff = splitter->coeff;
  63     z1 = splitter->hp_z1;
  64     for(i = 0;i < count;i++)
  65     {
  66         x = input[i];
  67
  68         d = x - coeff*z1;
  69         x = z1 + coeff*d;
  70         z1 = d;
  71
  72         hpout[i] = x - lpout[i];
  73     }
  74     splitter->hp_z1 = z1;
  75 }
  76
  77
  78 void splitterap_init(SplitterAllpass *splitter, ALfloat f0norm)
  79 {
  80     ALfloat w = f0norm * F_TAU;
  81     ALfloat cw = cosf(w);
  82     if(cw > FLT_EPSILON)
  83         splitter->coeff = (sinf(w) - 1.0f) / cw;
  84     else
  85         splitter->coeff = cw * -0.5f;
  86
  87     splitter->z1 = 0.0f;
  88 }
  89
  90 void splitterap_clear(SplitterAllpass *splitter)
  91 {
  92     splitter->z1 = 0.0f;
  93 }
  94
  95 void splitterap_process(SplitterAllpass *splitter, ALfloat *restrict samples, ALsizei count)
  96 {
  97     ALfloat coeff, d, x;
  98     ALfloat z1;
  99     ALsizei i;
 100
 101     coeff = splitter->coeff;
 102     z1 = splitter->z1;
 103     for(i = 0;i < count;i++)
 104     {
 105         x = samples[i];
 106
 107         d = x - coeff*z1;
 108         x = z1 + coeff*d;
 109         z1 = d;
 110
 111         samples[i] = x;
 112     }
 113     splitter->z1 = z1;
 114 }
 115
 116
 117 static const ALfloat UnitScale[MAX_AMBI_COEFFS] = {
 118     1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
 119     1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f
 120 };
 121 static const ALfloat SN3D2N3DScale[MAX_AMBI_COEFFS] = {
 122     1.000000000f, /* ACN  0 (W), sqrt(1) */
 123     1.732050808f, /* ACN  1 (Y), sqrt(3) */
 124     1.732050808f, /* ACN  2 (Z), sqrt(3) */
 125     1.732050808f, /* ACN  3 (X), sqrt(3) */
 126     2.236067978f, /* ACN  4 (V), sqrt(5) */
 127     2.236067978f, /* ACN  5 (T), sqrt(5) */
 128     2.236067978f, /* ACN  6 (R), sqrt(5) */
 129     2.236067978f, /* ACN  7 (S), sqrt(5) */
 130     2.236067978f, /* ACN  8 (U), sqrt(5) */
 131     2.645751311f, /* ACN  9 (Q), sqrt(7) */
 132     2.645751311f, /* ACN 10 (O), sqrt(7) */
 133     2.645751311f, /* ACN 11 (M), sqrt(7) */
 134     2.645751311f, /* ACN 12 (K), sqrt(7) */
 135     2.645751311f, /* ACN 13 (L), sqrt(7) */
 136     2.645751311f, /* ACN 14 (N), sqrt(7) */
 137     2.645751311f, /* ACN 15 (P), sqrt(7) */
 138 };
 139 static const ALfloat FuMa2N3DScale[MAX_AMBI_COEFFS] = {
 140     1.414213562f, /* ACN  0 (W), sqrt(2) */
 141     1.732050808f, /* ACN  1 (Y), sqrt(3) */
 142     1.732050808f, /* ACN  2 (Z), sqrt(3) */
 143     1.732050808f, /* ACN  3 (X), sqrt(3) */
 144     1.936491673f, /* ACN  4 (V), sqrt(15)/2 */
 145     1.936491673f, /* ACN  5 (T), sqrt(15)/2 */
 146     2.236067978f, /* ACN  6 (R), sqrt(5) */
 147     1.936491673f, /* ACN  7 (S), sqrt(15)/2 */
 148     1.936491673f, /* ACN  8 (U), sqrt(15)/2 */
 149     2.091650066f, /* ACN  9 (Q), sqrt(35/8) */
 150     1.972026594f, /* ACN 10 (O), sqrt(35)/3 */
 151     2.231093404f, /* ACN 11 (M), sqrt(224/45) */
 152     2.645751311f, /* ACN 12 (K), sqrt(7) */
 153     2.231093404f, /* ACN 13 (L), sqrt(224/45) */
 154     1.972026594f, /* ACN 14 (N), sqrt(35)/3 */
 155     2.091650066f, /* ACN 15 (P), sqrt(35/8) */
 156 };
 157
 158
 159 enum FreqBand {
 160     FB_HighFreq,
 161     FB_LowFreq,
 162     FB_Max
 163 };
 164
 165 /* These points are in AL coordinates! */
 166 static const ALfloat Ambi3DPoints[8][3] = {
 167     { -0.577350269f,  0.577350269f, -0.577350269f },
 168     {  0.577350269f,  0.577350269f, -0.577350269f },
 169     { -0.577350269f,  0.577350269f,  0.577350269f },
 170     {  0.577350269f,  0.577350269f,  0.577350269f },
 171     { -0.577350269f, -0.577350269f, -0.577350269f },
 172     {  0.577350269f, -0.577350269f, -0.577350269f },
 173     { -0.577350269f, -0.577350269f,  0.577350269f },
 174     {  0.577350269f, -0.577350269f,  0.577350269f },
 175 };
 176 static const ALfloat Ambi3DDecoder[8][FB_Max][MAX_AMBI_COEFFS] = {
 177     { { 0.25f,  0.1443375672f,  0.1443375672f,  0.1443375672f }, { 0.125f,  0.125f,  0.125f,  0.125f } },
 178     { { 0.25f, -0.1443375672f,  0.1443375672f,  0.1443375672f }, { 0.125f, -0.125f,  0.125f,  0.125f } },
 179     { { 0.25f,  0.1443375672f,  0.1443375672f, -0.1443375672f }, { 0.125f,  0.125f,  0.125f, -0.125f } },
 180     { { 0.25f, -0.1443375672f,  0.1443375672f, -0.1443375672f }, { 0.125f, -0.125f,  0.125f, -0.125f } },
 181     { { 0.25f,  0.1443375672f, -0.1443375672f,  0.1443375672f }, { 0.125f,  0.125f, -0.125f,  0.125f } },
 182     { { 0.25f, -0.1443375672f, -0.1443375672f,  0.1443375672f }, { 0.125f, -0.125f, -0.125f,  0.125f } },
 183     { { 0.25f,  0.1443375672f, -0.1443375672f, -0.1443375672f }, { 0.125f,  0.125f, -0.125f, -0.125f } },
 184     { { 0.25f, -0.1443375672f, -0.1443375672f, -0.1443375672f }, { 0.125f, -0.125f, -0.125f, -0.125f } },
 185 };
 186
 187
 188 static RowMixerFunc MixMatrixRow = MixRow_C;
 189
 190
 191 static alonce_flag bformatdec_inited = AL_ONCE_FLAG_INIT;
 192
 193 static void init_bformatdec(void)
 194 {
 195     MixMatrixRow = SelectRowMixer();
 196 }
 197
 198
 199 /* NOTE: BandSplitter filters are unused with single-band decoding */
 200 typedef struct BFormatDec {
 201     ALboolean Enabled[MAX_OUTPUT_CHANNELS];
 202
 203     union {
 204         alignas(16) ALfloat Dual[MAX_OUTPUT_CHANNELS][FB_Max][MAX_AMBI_COEFFS];
 205         alignas(16) ALfloat Single[MAX_OUTPUT_CHANNELS][MAX_AMBI_COEFFS];
 206     } Matrix;
 207
 208     BandSplitter XOver[MAX_AMBI_COEFFS];
 209
 210     ALfloat (*Samples)[BUFFERSIZE];
 211     /* These two alias into Samples */
 212     ALfloat (*SamplesHF)[BUFFERSIZE];
 213     ALfloat (*SamplesLF)[BUFFERSIZE];
 214
 215     alignas(16) ALfloat ChannelMix[BUFFERSIZE];
 216
 217     struct {
 218         BandSplitter XOver;
 219         ALfloat Gains[FB_Max];
 220     } UpSampler[4];
 221
 222     ALsizei NumChannels;
 223     ALboolean DualBand;
 224 } BFormatDec;
 225
 226 BFormatDec *bformatdec_alloc()
 227 {
 228     alcall_once(&bformatdec_inited, init_bformatdec);
 229     return al_calloc(16, sizeof(BFormatDec));
 230 }
 231
 232 void bformatdec_free(BFormatDec *dec)
 233 {
 234     if(dec)
 235     {
 236         al_free(dec->Samples);
 237         dec->Samples = NULL;
 238         dec->SamplesHF = NULL;
 239         dec->SamplesLF = NULL;
 240
 241         memset(dec, 0, sizeof(*dec));
 242         al_free(dec);
 243     }
 244 }
 245
 246 void bformatdec_reset(BFormatDec *dec, const AmbDecConf *conf, ALsizei chancount, ALuint srate, const ALsizei chanmap[MAX_OUTPUT_CHANNELS])
 247 {
 248     static const ALsizei map2DTo3D[MAX_AMBI2D_COEFFS] = {
 249         0,  1, 3,  4, 8,  9, 15
 250     };
 251     const ALfloat *coeff_scale = UnitScale;
 252     bool periphonic;
 253     ALfloat ratio;
 254     ALsizei i;
 255
 256     al_free(dec->Samples);
 257     dec->Samples = NULL;
 258     dec->SamplesHF = NULL;
 259     dec->SamplesLF = NULL;
 260
 261     dec->NumChannels = chancount;
 262     dec->Samples = al_calloc(16, dec->NumChannels*2 * sizeof(dec->Samples[0]));
 263     dec->SamplesHF = dec->Samples;
 264     dec->SamplesLF = dec->SamplesHF + dec->NumChannels;
 265
 266     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 267         dec->Enabled[i] = AL_FALSE;
 268     for(i = 0;i < conf->NumSpeakers;i++)
 269         dec->Enabled[chanmap[i]] = AL_TRUE;
 270
 271     if(conf->CoeffScale == ADS_SN3D)
 272         coeff_scale = SN3D2N3DScale;
 273     else if(conf->CoeffScale == ADS_FuMa)
 274         coeff_scale = FuMa2N3DScale;
 275
 276     memset(dec->UpSampler, 0, sizeof(dec->UpSampler));
 277     ratio = 400.0f / (ALfloat)srate;
 278     for(i = 0;i < 4;i++)
 279         bandsplit_init(&dec->UpSampler[i].XOver, ratio);
 280     if((conf->ChanMask&AMBI_PERIPHONIC_MASK))
 281     {
 282         periphonic = true;
 283
 284         dec->UpSampler[0].Gains[FB_HighFreq] = (dec->NumChannels > 9) ? W_SCALE3D_THIRD :
 285                                                (dec->NumChannels > 4) ? W_SCALE3D_SECOND : 1.0f;
 286         dec->UpSampler[0].Gains[FB_LowFreq] = 1.0f;
 287         for(i = 1;i < 4;i++)
 288         {
 289             dec->UpSampler[i].Gains[FB_HighFreq] = (dec->NumChannels > 9) ? XYZ_SCALE3D_THIRD :
 290                                                    (dec->NumChannels > 4) ? XYZ_SCALE3D_SECOND : 1.0f;
 291             dec->UpSampler[i].Gains[FB_LowFreq] = 1.0f;
 292         }
 293     }
 294     else
 295     {
 296         periphonic = false;
 297
 298         dec->UpSampler[0].Gains[FB_HighFreq] = (dec->NumChannels > 5) ? W_SCALE2D_THIRD :
 299                                                (dec->NumChannels > 3) ? W_SCALE2D_SECOND : 1.0f;
 300         dec->UpSampler[0].Gains[FB_LowFreq] = 1.0f;
 301         for(i = 1;i < 3;i++)
 302         {
 303             dec->UpSampler[i].Gains[FB_HighFreq] = (dec->NumChannels > 5) ? XYZ_SCALE2D_THIRD :
 304                                                    (dec->NumChannels > 3) ? XYZ_SCALE2D_SECOND : 1.0f;
 305             dec->UpSampler[i].Gains[FB_LowFreq] = 1.0f;
 306         }
 307         dec->UpSampler[3].Gains[FB_HighFreq] = 0.0f;
 308         dec->UpSampler[3].Gains[FB_LowFreq] = 0.0f;
 309     }
 310
 311     memset(&dec->Matrix, 0, sizeof(dec->Matrix));
 312     if(conf->FreqBands == 1)
 313     {
 314         dec->DualBand = AL_FALSE;
 315         for(i = 0;i < conf->NumSpeakers;i++)
 316         {
 317             ALsizei chan = chanmap[i];
 318             ALfloat gain;
 319             ALsizei j, k;
 320
 321             if(!periphonic)
 322             {
 323                 for(j = 0,k = 0;j < MAX_AMBI2D_COEFFS;j++)
 324                 {
 325                     ALsizei l = map2DTo3D[j];
 326                     if(j == 0) gain = conf->HFOrderGain[0];
 327                     else if(j == 1) gain = conf->HFOrderGain[1];
 328                     else if(j == 3) gain = conf->HFOrderGain[2];
 329                     else if(j == 5) gain = conf->HFOrderGain[3];
 330                     if((conf->ChanMask&(1<<l)))
 331                         dec->Matrix.Single[chan][j] = conf->HFMatrix[i][k++] / coeff_scale[l] *
 332                                                       gain;
 333                 }
 334             }
 335             else
 336             {
 337                 for(j = 0,k = 0;j < MAX_AMBI_COEFFS;j++)
 338                 {
 339                     if(j == 0) gain = conf->HFOrderGain[0];
 340                     else if(j == 1) gain = conf->HFOrderGain[1];
 341                     else if(j == 4) gain = conf->HFOrderGain[2];
 342                     else if(j == 9) gain = conf->HFOrderGain[3];
 343                     if((conf->ChanMask&(1<<j)))
 344                         dec->Matrix.Single[chan][j] = conf->HFMatrix[i][k++] / coeff_scale[j] *
 345                                                       gain;
 346                 }
 347             }
 348         }
 349     }
 350     else
 351     {
 352         dec->DualBand = AL_TRUE;
 353
 354         ratio = conf->XOverFreq / (ALfloat)srate;
 355         for(i = 0;i < MAX_AMBI_COEFFS;i++)
 356             bandsplit_init(&dec->XOver[i], ratio);
 357
 358         ratio = powf(10.0f, conf->XOverRatio / 40.0f);
 359         for(i = 0;i < conf->NumSpeakers;i++)
 360         {
 361             ALsizei chan = chanmap[i];
 362             ALfloat gain;
 363             ALsizei j, k;
 364
 365             if(!periphonic)
 366             {
 367                 for(j = 0,k = 0;j < MAX_AMBI2D_COEFFS;j++)
 368                 {
 369                     ALsizei l = map2DTo3D[j];
 370                     if(j == 0) gain = conf->HFOrderGain[0] * ratio;
 371                     else if(j == 1) gain = conf->HFOrderGain[1] * ratio;
 372                     else if(j == 3) gain = conf->HFOrderGain[2] * ratio;
 373                     else if(j == 5) gain = conf->HFOrderGain[3] * ratio;
 374                     if((conf->ChanMask&(1<<l)))
 375                         dec->Matrix.Dual[chan][FB_HighFreq][j] = conf->HFMatrix[i][k++] /
 376                                                                  coeff_scale[l] * gain;
 377                 }
 378                 for(j = 0,k = 0;j < MAX_AMBI2D_COEFFS;j++)
 379                 {
 380                     ALsizei l = map2DTo3D[j];
 381                     if(j == 0) gain = conf->LFOrderGain[0] / ratio;
 382                     else if(j == 1) gain = conf->LFOrderGain[1] / ratio;
 383                     else if(j == 3) gain = conf->LFOrderGain[2] / ratio;
 384                     else if(j == 5) gain = conf->LFOrderGain[3] / ratio;
 385                     if((conf->ChanMask&(1<<l)))
 386                         dec->Matrix.Dual[chan][FB_LowFreq][j] = conf->LFMatrix[i][k++] /
 387                                                                 coeff_scale[l] * gain;
 388                 }
 389             }
 390             else
 391             {
 392                 for(j = 0,k = 0;j < MAX_AMBI_COEFFS;j++)
 393                 {
 394                     if(j == 0) gain = conf->HFOrderGain[0] * ratio;
 395                     else if(j == 1) gain = conf->HFOrderGain[1] * ratio;
 396                     else if(j == 4) gain = conf->HFOrderGain[2] * ratio;
 397                     else if(j == 9) gain = conf->HFOrderGain[3] * ratio;
 398                     if((conf->ChanMask&(1<<j)))
 399                         dec->Matrix.Dual[chan][FB_HighFreq][j] = conf->HFMatrix[i][k++] /
 400                                                                  coeff_scale[j] * gain;
 401                 }
 402                 for(j = 0,k = 0;j < MAX_AMBI_COEFFS;j++)
 403                 {
 404                     if(j == 0) gain = conf->LFOrderGain[0] / ratio;
 405                     else if(j == 1) gain = conf->LFOrderGain[1] / ratio;
 406                     else if(j == 4) gain = conf->LFOrderGain[2] / ratio;
 407                     else if(j == 9) gain = conf->LFOrderGain[3] / ratio;
 408                     if((conf->ChanMask&(1<<j)))
 409                         dec->Matrix.Dual[chan][FB_LowFreq][j] = conf->LFMatrix[i][k++] /
 410                                                                 coeff_scale[j] * gain;
 411                 }
 412             }
 413         }
 414     }
 415 }
 416
 417
 418 void bformatdec_process(struct BFormatDec *dec, ALfloat (*restrict OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei SamplesToDo)
 419 {
 420     ALsizei chan, i;
 421
 422     OutBuffer = ASSUME_ALIGNED(OutBuffer, 16);
 423     if(dec->DualBand)
 424     {
 425         for(i = 0;i < dec->NumChannels;i++)
 426             bandsplit_process(&dec->XOver[i], dec->SamplesHF[i], dec->SamplesLF[i],
 427                               InSamples[i], SamplesToDo);
 428
 429         for(chan = 0;chan < OutChannels;chan++)
 430         {
 431             if(!dec->Enabled[chan])
 432                 continue;
 433
 434             memset(dec->ChannelMix, 0, SamplesToDo*sizeof(ALfloat));
 435             MixMatrixRow(dec->ChannelMix, dec->Matrix.Dual[chan][FB_HighFreq],
 436                 dec->SamplesHF, dec->NumChannels, 0, SamplesToDo
 437             );
 438             MixMatrixRow(dec->ChannelMix, dec->Matrix.Dual[chan][FB_LowFreq],
 439                 dec->SamplesLF, dec->NumChannels, 0, SamplesToDo
 440             );
 441
 442             for(i = 0;i < SamplesToDo;i++)
 443                 OutBuffer[chan][i] += dec->ChannelMix[i];
 444         }
 445     }
 446     else
 447     {
 448         for(chan = 0;chan < OutChannels;chan++)
 449         {
 450             if(!dec->Enabled[chan])
 451                 continue;
 452
 453             memset(dec->ChannelMix, 0, SamplesToDo*sizeof(ALfloat));
 454             MixMatrixRow(dec->ChannelMix, dec->Matrix.Single[chan], InSamples,
 455                          dec->NumChannels, 0, SamplesToDo);
 456
 457             for(i = 0;i < SamplesToDo;i++)
 458                 OutBuffer[chan][i] += dec->ChannelMix[i];
 459         }
 460     }
 461 }
 462
 463
 464 void bformatdec_upSample(struct BFormatDec *dec, ALfloat (*restrict OutBuffer)[BUFFERSIZE], const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei InChannels, ALsizei SamplesToDo)
 465 {
 466     ALsizei i;
 467
 468     /* This up-sampler leverages the differences observed in dual-band second-
 469      * and third-order decoder matrices compared to first-order. For the same
 470      * output channel configuration, the low-frequency matrix has identical
 471      * coefficients in the shared input channels, while the high-frequency
 472      * matrix has extra scalars applied to the W channel and X/Y/Z channels.
 473      * Mixing the first-order content into the higher-order stream with the
 474      * appropriate counter-scales applied to the HF response results in the
 475      * subsequent higher-order decode generating the same response as a first-
 476      * order decode.
 477      */
 478     for(i = 0;i < InChannels;i++)
 479     {
 480         /* First, split the first-order components into low and high frequency
 481          * bands.
 482          */
 483         bandsplit_process(&dec->UpSampler[i].XOver,
 484             dec->Samples[FB_HighFreq], dec->Samples[FB_LowFreq],
 485             InSamples[i], SamplesToDo
 486         );
 487
 488         /* Now write each band to the output. */
 489         MixMatrixRow(OutBuffer[i], dec->UpSampler[i].Gains,
 490             dec->Samples, FB_Max, 0, SamplesToDo
 491         );
 492     }
 493 }
 494
 495
 496 #define INVALID_UPSAMPLE_INDEX INT_MAX
 497
 498 static ALsizei GetACNIndex(const BFChannelConfig *chans, ALsizei numchans, ALsizei acn)
 499 {
 500     ALsizei i;
 501     for(i = 0;i < numchans;i++)
 502     {
 503         if(chans[i].Index == acn)
 504             return i;
 505     }
 506     return INVALID_UPSAMPLE_INDEX;
 507 }
 508 #define GetChannelForACN(b, a) GetACNIndex((b).Ambi.Map, (b).NumChannels, (a))
 509
 510 typedef struct AmbiUpsampler {
 511     alignas(16) ALfloat Samples[FB_Max][BUFFERSIZE];
 512
 513     BandSplitter XOver[4];
 514
 515     ALfloat Gains[4][MAX_OUTPUT_CHANNELS][FB_Max];
 516 } AmbiUpsampler;
 517
 518 AmbiUpsampler *ambiup_alloc()
 519 {
 520     alcall_once(&bformatdec_inited, init_bformatdec);
 521     return al_calloc(16, sizeof(AmbiUpsampler));
 522 }
 523
 524 void ambiup_free(struct AmbiUpsampler *ambiup)
 525 {
 526     al_free(ambiup);
 527 }
 528
 529 void ambiup_reset(struct AmbiUpsampler *ambiup, const ALCdevice *device)
 530 {
 531     ALfloat ratio;
 532     ALsizei i;
 533
 534     ratio = 400.0f / (ALfloat)device->Frequency;
 535     for(i = 0;i < 4;i++)
 536         bandsplit_init(&ambiup->XOver[i], ratio);
 537
 538     memset(ambiup->Gains, 0, sizeof(ambiup->Gains));
 539     if(device->Dry.CoeffCount > 0)
 540     {
 541         ALfloat encgains[8][MAX_OUTPUT_CHANNELS];
 542         ALsizei j;
 543         size_t k;
 544
 545         for(k = 0;k < COUNTOF(Ambi3DPoints);k++)
 546         {
 547             ALfloat coeffs[MAX_AMBI_COEFFS] = { 0.0f };
 548             CalcDirectionCoeffs(Ambi3DPoints[k], 0.0f, coeffs);
 549             ComputeDryPanGains(&device->Dry, coeffs, 1.0f, encgains[k]);
 550         }
 551
 552         /* Combine the matrices that do the in->virt and virt->out conversions
 553          * so we get a single in->out conversion. NOTE: the Encoder matrix
 554          * (encgains) and output are transposed, so the input channels line up
 555          * with the rows and the output channels line up with the columns.
 556          */
 557         for(i = 0;i < 4;i++)
 558         {
 559             for(j = 0;j < device->Dry.NumChannels;j++)
 560             {
 561                 ALfloat hfgain=0.0f, lfgain=0.0f;
 562                 for(k = 0;k < COUNTOF(Ambi3DDecoder);k++)
 563                 {
 564                     hfgain += Ambi3DDecoder[k][FB_HighFreq][i]*encgains[k][j];
 565                     lfgain += Ambi3DDecoder[k][FB_LowFreq][i]*encgains[k][j];
 566                 }
 567                 ambiup->Gains[i][j][FB_HighFreq] = hfgain;
 568                 ambiup->Gains[i][j][FB_LowFreq] = lfgain;
 569             }
 570         }
 571     }
 572     else
 573     {
 574         /* Assumes full 3D/periphonic on the input and output mixes! */
 575         ALfloat w_scale = (device->Dry.NumChannels > 9) ? W_SCALE3D_THIRD :
 576                           (device->Dry.NumChannels > 4) ? W_SCALE3D_SECOND : 1.0f;
 577         ALfloat xyz_scale = (device->Dry.NumChannels > 9) ? XYZ_SCALE3D_THIRD :
 578                             (device->Dry.NumChannels > 4) ? XYZ_SCALE3D_SECOND : 1.0f;
 579         for(i = 0;i < 4;i++)
 580         {
 581             ALsizei index = GetChannelForACN(device->Dry, i);
 582             if(index != INVALID_UPSAMPLE_INDEX)
 583             {
 584                 ALfloat scale = device->Dry.Ambi.Map[index].Scale;
 585                 ambiup->Gains[i][index][FB_HighFreq] = scale * ((i==0) ? w_scale : xyz_scale);
 586                 ambiup->Gains[i][index][FB_LowFreq] = scale;
 587             }
 588         }
 589     }
 590 }
 591
 592 void ambiup_process(struct AmbiUpsampler *ambiup, ALfloat (*restrict OutBuffer)[BUFFERSIZE], ALsizei OutChannels, const ALfloat (*restrict InSamples)[BUFFERSIZE], ALsizei SamplesToDo)
 593 {
 594     ALsizei i, j;
 595
 596     for(i = 0;i < 4;i++)
 597     {
 598         bandsplit_process(&ambiup->XOver[i],
 599             ambiup->Samples[FB_HighFreq], ambiup->Samples[FB_LowFreq],
 600             InSamples[i], SamplesToDo
 601         );
 602
 603         for(j = 0;j < OutChannels;j++)
 604             MixMatrixRow(OutBuffer[j], ambiup->Gains[i][j],
 605                 ambiup->Samples, FB_Max, 0, SamplesToDo
 606             );
 607     }
 608 }