?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use a more specialized mixer function for B-Format to HRTF
[openal-soft.git] / Alc / panning.c
blob70494547184f3595e9b6793a7da544813a2c5001
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 #include "ambdec.h"
34 #include "bformatdec.h"
35 #include "uhjfilter.h"
36 #include "bs2b.h"
37
38
39 extern inline void CalcXYZCoeffs(ALfloat x, ALfloat y, ALfloat z, ALfloat spread, ALfloat coeffs[MAX_AMBI_COEFFS]);
40
41
42 #define ZERO_ORDER_SCALE 0.0f
43 #define FIRST_ORDER_SCALE 1.0f
44 #define SECOND_ORDER_SCALE (1.0f / 1.22474f)
45 #define THIRD_ORDER_SCALE (1.0f / 1.30657f)
46
47
48 static const ALuint FuMa2ACN[MAX_AMBI_COEFFS] = {
49 0, /* W */
50 3, /* X */
51 1, /* Y */
52 2, /* Z */
53 6, /* R */
54 7, /* S */
55 5, /* T */
56 8, /* U */
57 4, /* V */
58 12, /* K */
59 13, /* L */
60 11, /* M */
61 14, /* N */
62 10, /* O */
63 15, /* P */
64 9, /* Q */
65 };
66 static const ALuint ACN2ACN[MAX_AMBI_COEFFS] = {
67 0, 1, 2, 3, 4, 5, 6, 7,
68 8, 9, 10, 11, 12, 13, 14, 15
69 };
70
71 /* NOTE: These are scale factors as applied to Ambisonics content. Decoder
72 * coefficients should be divided by these values to get proper N3D scalings.
73 */
74 static const ALfloat UnitScale[MAX_AMBI_COEFFS] = {
75 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
76 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f
77 };
78 static const ALfloat SN3D2N3DScale[MAX_AMBI_COEFFS] = {
79 1.000000000f, /* ACN 0 (W), sqrt(1) */
80 1.732050808f, /* ACN 1 (Y), sqrt(3) */
81 1.732050808f, /* ACN 2 (Z), sqrt(3) */
82 1.732050808f, /* ACN 3 (X), sqrt(3) */
83 2.236067978f, /* ACN 4 (V), sqrt(5) */
84 2.236067978f, /* ACN 5 (T), sqrt(5) */
85 2.236067978f, /* ACN 6 (R), sqrt(5) */
86 2.236067978f, /* ACN 7 (S), sqrt(5) */
87 2.236067978f, /* ACN 8 (U), sqrt(5) */
88 2.645751311f, /* ACN 9 (Q), sqrt(7) */
89 2.645751311f, /* ACN 10 (O), sqrt(7) */
90 2.645751311f, /* ACN 11 (M), sqrt(7) */
91 2.645751311f, /* ACN 12 (K), sqrt(7) */
92 2.645751311f, /* ACN 13 (L), sqrt(7) */
93 2.645751311f, /* ACN 14 (N), sqrt(7) */
94 2.645751311f, /* ACN 15 (P), sqrt(7) */
95 };
96 static const ALfloat FuMa2N3DScale[MAX_AMBI_COEFFS] = {
97 1.414213562f, /* ACN 0 (W), sqrt(2) */
98 1.732050808f, /* ACN 1 (Y), sqrt(3) */
99 1.732050808f, /* ACN 2 (Z), sqrt(3) */
100 1.732050808f, /* ACN 3 (X), sqrt(3) */
101 1.936491673f, /* ACN 4 (V), sqrt(15)/2 */
102 1.936491673f, /* ACN 5 (T), sqrt(15)/2 */
103 2.236067978f, /* ACN 6 (R), sqrt(5) */
104 1.936491673f, /* ACN 7 (S), sqrt(15)/2 */
105 1.936491673f, /* ACN 8 (U), sqrt(15)/2 */
106 2.091650066f, /* ACN 9 (Q), sqrt(35/8) */
107 1.972026594f, /* ACN 10 (O), sqrt(35)/3 */
108 2.231093404f, /* ACN 11 (M), sqrt(224/45) */
109 2.645751311f, /* ACN 12 (K), sqrt(7) */
110 2.231093404f, /* ACN 13 (L), sqrt(224/45) */
111 1.972026594f, /* ACN 14 (N), sqrt(35)/3 */
112 2.091650066f, /* ACN 15 (P), sqrt(35/8) */
113 };
114
115
116 void CalcDirectionCoeffs(const ALfloat dir[3], ALfloat spread, ALfloat coeffs[MAX_AMBI_COEFFS])
117 {
118 /* Convert from OpenAL coords to Ambisonics. */
119 ALfloat x = -dir[2];
120 ALfloat y = -dir[0];
121 ALfloat z = dir[1];
122
123 /* Zeroth-order */
124 coeffs[0] = 1.0f; /* ACN 0 = 1 */
125 /* First-order */
126 coeffs[1] = 1.732050808f * y; /* ACN 1 = sqrt(3) * Y */
127 coeffs[2] = 1.732050808f * z; /* ACN 2 = sqrt(3) * Z */
128 coeffs[3] = 1.732050808f * x; /* ACN 3 = sqrt(3) * X */
129 /* Second-order */
130 coeffs[4] = 3.872983346f * x * y; /* ACN 4 = sqrt(15) * X * Y */
131 coeffs[5] = 3.872983346f * y * z; /* ACN 5 = sqrt(15) * Y * Z */
132 coeffs[6] = 1.118033989f * (3.0f*z*z - 1.0f); /* ACN 6 = sqrt(5)/2 * (3*Z*Z - 1) */
133 coeffs[7] = 3.872983346f * x * z; /* ACN 7 = sqrt(15) * X * Z */
134 coeffs[8] = 1.936491673f * (x*x - y*y); /* ACN 8 = sqrt(15)/2 * (X*X - Y*Y) */
135 /* Third-order */
136 coeffs[9] = 2.091650066f * y * (3.0f*x*x - y*y); /* ACN 9 = sqrt(35/8) * Y * (3*X*X - Y*Y) */
137 coeffs[10] = 10.246950766f * z * x * y; /* ACN 10 = sqrt(105) * Z * X * Y */
138 coeffs[11] = 1.620185175f * y * (5.0f*z*z - 1.0f); /* ACN 11 = sqrt(21/8) * Y * (5*Z*Z - 1) */
139 coeffs[12] = 1.322875656f * z * (5.0f*z*z - 3.0f); /* ACN 12 = sqrt(7)/2 * Z * (5*Z*Z - 3) */
140 coeffs[13] = 1.620185175f * x * (5.0f*z*z - 1.0f); /* ACN 13 = sqrt(21/8) * X * (5*Z*Z - 1) */
141 coeffs[14] = 5.123475383f * z * (x*x - y*y); /* ACN 14 = sqrt(105)/2 * Z * (X*X - Y*Y) */
142 coeffs[15] = 2.091650066f * x * (x*x - 3.0f*y*y); /* ACN 15 = sqrt(35/8) * X * (X*X - 3*Y*Y) */
143
144 if(spread > 0.0f)
145 {
146 /* Implement the spread by using a spherical source that subtends the
147 * angle spread. See:
148 * http://www.ppsloan.org/publications/StupidSH36.pdf - Appendix A3
149 *
150 * When adjusted for N3D normalization instead of SN3D, these
151 * calculations are:
152 *
153 * ZH0 = -sqrt(pi) * (-1+ca);
154 * ZH1 = 0.5*sqrt(pi) * sa*sa;
155 * ZH2 = -0.5*sqrt(pi) * ca*(-1+ca)*(ca+1);
156 * ZH3 = -0.125*sqrt(pi) * (-1+ca)*(ca+1)*(5*ca*ca - 1);
157 * ZH4 = -0.125*sqrt(pi) * ca*(-1+ca)*(ca+1)*(7*ca*ca - 3);
158 * ZH5 = -0.0625*sqrt(pi) * (-1+ca)*(ca+1)*(21*ca*ca*ca*ca - 14*ca*ca + 1);
159 *
160 * The gain of the source is compensated for size, so that the
161 * loundness doesn't depend on the spread. That is, the factors are
162 * scaled so that ZH0 remains 1 regardless of the spread. Thus:
163 *
164 * ZH0 = 1.0f;
165 * ZH1 = 0.5f * (ca+1.0f);
166 * ZH2 = 0.5f * (ca+1.0f)*ca;
167 * ZH3 = 0.125f * (ca+1.0f)*(5.0f*ca*ca - 1.0f);
168 * ZH4 = 0.125f * (ca+1.0f)*(7.0f*ca*ca - 3.0f)*ca;
169 * ZH5 = 0.0625f * (ca+1.0f)*(21.0f*ca*ca*ca*ca - 14.0f*ca*ca + 1.0f);
170 */
171 ALfloat ca = cosf(spread * 0.5f);
172
173 ALfloat ZH0_norm = 1.0f;
174 ALfloat ZH1_norm = 0.5f * (ca+1.f);
175 ALfloat ZH2_norm = 0.5f * (ca+1.f)*ca;
176 ALfloat ZH3_norm = 0.125f * (ca+1.f)*(5.f*ca*ca-1.f);
177
178 /* Zeroth-order */
179 coeffs[0] *= ZH0_norm;
180 /* First-order */
181 coeffs[1] *= ZH1_norm;
182 coeffs[2] *= ZH1_norm;
183 coeffs[3] *= ZH1_norm;
184 /* Second-order */
185 coeffs[4] *= ZH2_norm;
186 coeffs[5] *= ZH2_norm;
187 coeffs[6] *= ZH2_norm;
188 coeffs[7] *= ZH2_norm;
189 coeffs[8] *= ZH2_norm;
190 /* Third-order */
191 coeffs[9] *= ZH3_norm;
192 coeffs[10] *= ZH3_norm;
193 coeffs[11] *= ZH3_norm;
194 coeffs[12] *= ZH3_norm;
195 coeffs[13] *= ZH3_norm;
196 coeffs[14] *= ZH3_norm;
197 coeffs[15] *= ZH3_norm;
198 }
199 }
200
201 void CalcAngleCoeffs(ALfloat azimuth, ALfloat elevation, ALfloat spread, ALfloat coeffs[MAX_AMBI_COEFFS])
202 {
203 ALfloat dir[3] = {
204 sinf(azimuth) * cosf(elevation),
205 sinf(elevation),
206 -cosf(azimuth) * cosf(elevation)
207 };
208 CalcDirectionCoeffs(dir, spread, coeffs);
209 }
210
211
212 void ComputeAmbientGainsMC(const ChannelConfig *chancoeffs, ALuint numchans, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
213 {
214 ALuint i;
215
216 for(i = 0;i < numchans;i++)
217 {
218 // The W coefficients are based on a mathematical average of the
219 // output. The square root of the base average provides for a more
220 // perceptual average volume, better suited to non-directional gains.
221 gains[i] = sqrtf(chancoeffs[i][0]) * ingain;
222 }
223 for(;i < MAX_OUTPUT_CHANNELS;i++)
224 gains[i] = 0.0f;
225 }
226
227 void ComputeAmbientGainsBF(const BFChannelConfig *chanmap, ALuint numchans, ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
228 {
229 ALfloat gain = 0.0f;
230 ALuint i;
231
232 for(i = 0;i < numchans;i++)
233 {
234 if(chanmap[i].Index == 0)
235 gain += chanmap[i].Scale;
236 }
237 gains[0] = gain * 1.414213562f * ingain;
238 for(i = 1;i < MAX_OUTPUT_CHANNELS;i++)
239 gains[i] = 0.0f;
240 }
241
242 void ComputePanningGainsMC(const ChannelConfig *chancoeffs, ALuint numchans, ALuint numcoeffs, const ALfloat coeffs[MAX_AMBI_COEFFS], ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
243 {
244 ALuint i, j;
245
246 for(i = 0;i < numchans;i++)
247 {
248 float gain = 0.0f;
249 for(j = 0;j < numcoeffs;j++)
250 gain += chancoeffs[i][j]*coeffs[j];
251 gains[i] = gain * ingain;
252 }
253 for(;i < MAX_OUTPUT_CHANNELS;i++)
254 gains[i] = 0.0f;
255 }
256
257 void ComputePanningGainsBF(const BFChannelConfig *chanmap, ALuint numchans, const ALfloat coeffs[MAX_AMBI_COEFFS], ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
258 {
259 ALuint i;
260
261 for(i = 0;i < numchans;i++)
262 gains[i] = chanmap[i].Scale * coeffs[chanmap[i].Index] * ingain;
263 for(;i < MAX_OUTPUT_CHANNELS;i++)
264 gains[i] = 0.0f;
265 }
266
267 void ComputeFirstOrderGainsMC(const ChannelConfig *chancoeffs, ALuint numchans, const ALfloat mtx[4], ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
268 {
269 ALuint i, j;
270
271 for(i = 0;i < numchans;i++)
272 {
273 float gain = 0.0f;
274 for(j = 0;j < 4;j++)
275 gain += chancoeffs[i][j] * mtx[j];
276 gains[i] = gain * ingain;
277 }
278 for(;i < MAX_OUTPUT_CHANNELS;i++)
279 gains[i] = 0.0f;
280 }
281
282 void ComputeFirstOrderGainsBF(const BFChannelConfig *chanmap, ALuint numchans, const ALfloat mtx[4], ALfloat ingain, ALfloat gains[MAX_OUTPUT_CHANNELS])
283 {
284 ALuint i;
285
286 for(i = 0;i < numchans;i++)
287 gains[i] = chanmap[i].Scale * mtx[chanmap[i].Index] * ingain;
288 for(;i < MAX_OUTPUT_CHANNELS;i++)
289 gains[i] = 0.0f;
290 }
291
292
293 DECL_CONST static inline const char *GetLabelFromChannel(enum Channel channel)
294 {
295 switch(channel)
296 {
297 case FrontLeft: return "front-left";
298 case FrontRight: return "front-right";
299 case FrontCenter: return "front-center";
300 case LFE: return "lfe";
301 case BackLeft: return "back-left";
302 case BackRight: return "back-right";
303 case BackCenter: return "back-center";
304 case SideLeft: return "side-left";
305 case SideRight: return "side-right";
306
307 case UpperFrontLeft: return "upper-front-left";
308 case UpperFrontRight: return "upper-front-right";
309 case UpperBackLeft: return "upper-back-left";
310 case UpperBackRight: return "upper-back-right";
311 case LowerFrontLeft: return "lower-front-left";
312 case LowerFrontRight: return "lower-front-right";
313 case LowerBackLeft: return "lower-back-left";
314 case LowerBackRight: return "lower-back-right";
315
316 case Aux0: return "aux-0";
317 case Aux1: return "aux-1";
318 case Aux2: return "aux-2";
319 case Aux3: return "aux-3";
320 case Aux4: return "aux-4";
321 case Aux5: return "aux-5";
322 case Aux6: return "aux-6";
323 case Aux7: return "aux-7";
324 case Aux8: return "aux-8";
325 case Aux9: return "aux-9";
326 case Aux10: return "aux-10";
327 case Aux11: return "aux-11";
328 case Aux12: return "aux-12";
329 case Aux13: return "aux-13";
330 case Aux14: return "aux-14";
331 case Aux15: return "aux-15";
332
333 case InvalidChannel: break;
334 }
335 return "(unknown)";
336 }
337
338
339 typedef struct ChannelMap {
340 enum Channel ChanName;
341 ChannelConfig Config;
342 } ChannelMap;
343
344 static void SetChannelMap(const enum Channel *devchans, ChannelConfig *ambicoeffs,
345 const ChannelMap *chanmap, size_t count, ALuint *outcount,
346 ALboolean isfuma)
347 {
348 const ALuint *acnmap = isfuma ? FuMa2ACN : ACN2ACN;
349 const ALfloat *n3dscale = isfuma ? FuMa2N3DScale : UnitScale;
350 size_t j, k;
351 ALuint i;
352
353 for(i = 0;i < MAX_OUTPUT_CHANNELS && devchans[i] != InvalidChannel;i++)
354 {
355 if(devchans[i] == LFE)
356 {
357 for(j = 0;j < MAX_AMBI_COEFFS;j++)
358 ambicoeffs[i][j] = 0.0f;
359 continue;
360 }
361
362 for(j = 0;j < count;j++)
363 {
364 if(devchans[i] != chanmap[j].ChanName)
365 continue;
366
367 for(k = 0;k < MAX_AMBI_COEFFS;++k)
368 {
369 ALuint acn = acnmap[k];
370 ambicoeffs[i][acn] = chanmap[j].Config[k] / n3dscale[acn];
371 }
372 break;
373 }
374 if(j == count)
375 ERR("Failed to match %s channel (%u) in channel map\n", GetLabelFromChannel(devchans[i]), i);
376 }
377 *outcount = i;
378 }
379
380 static bool MakeSpeakerMap(ALCdevice *device, const AmbDecConf *conf, ALuint speakermap[MAX_OUTPUT_CHANNELS])
381 {
382 ALuint i;
383
384 for(i = 0;i < conf->NumSpeakers;i++)
385 {
386 int c = -1;
387
388 /* NOTE: AmbDec does not define any standard speaker names, however
389 * for this to work we have to by able to find the output channel
390 * the speaker definition corresponds to. Therefore, OpenAL Soft
391 * requires these channel labels to be recognized:
392 *
393 * LF = Front left
394 * RF = Front right
395 * LS = Side left
396 * RS = Side right
397 * LB = Back left
398 * RB = Back right
399 * CE = Front center
400 * CB = Back center
401 *
402 * Additionally, surround51 will acknowledge back speakers for side
403 * channels, and surround51rear will acknowledge side speakers for
404 * back channels, to avoid issues with an ambdec expecting 5.1 to
405 * use the side channels when the device is configured for back,
406 * and vice-versa.
407 */
408 if(al_string_cmp_cstr(conf->Speakers[i].Name, "LF") == 0)
409 c = GetChannelIdxByName(device->RealOut, FrontLeft);
410 else if(al_string_cmp_cstr(conf->Speakers[i].Name, "RF") == 0)
411 c = GetChannelIdxByName(device->RealOut, FrontRight);
412 else if(al_string_cmp_cstr(conf->Speakers[i].Name, "CE") == 0)
413 c = GetChannelIdxByName(device->RealOut, FrontCenter);
414 else if(al_string_cmp_cstr(conf->Speakers[i].Name, "LS") == 0)
415 {
416 if(device->FmtChans == DevFmtX51Rear)
417 c = GetChannelIdxByName(device->RealOut, BackLeft);
418 else
419 c = GetChannelIdxByName(device->RealOut, SideLeft);
420 }
421 else if(al_string_cmp_cstr(conf->Speakers[i].Name, "RS") == 0)
422 {
423 if(device->FmtChans == DevFmtX51Rear)
424 c = GetChannelIdxByName(device->RealOut, BackRight);
425 else
426 c = GetChannelIdxByName(device->RealOut, SideRight);
427 }
428 else if(al_string_cmp_cstr(conf->Speakers[i].Name, "LB") == 0)
429 {
430 if(device->FmtChans == DevFmtX51)
431 c = GetChannelIdxByName(device->RealOut, SideLeft);
432 else
433 c = GetChannelIdxByName(device->RealOut, BackLeft);
434 }
435 else if(al_string_cmp_cstr(conf->Speakers[i].Name, "RB") == 0)
436 {
437 if(device->FmtChans == DevFmtX51)
438 c = GetChannelIdxByName(device->RealOut, SideRight);
439 else
440 c = GetChannelIdxByName(device->RealOut, BackRight);
441 }
442 else if(al_string_cmp_cstr(conf->Speakers[i].Name, "CB") == 0)
443 c = GetChannelIdxByName(device->RealOut, BackCenter);
444 else
445 {
446 const char *name = al_string_get_cstr(conf->Speakers[i].Name);
447 unsigned int n;
448 char ch;
449
450 if(sscanf(name, "AUX%u%c", &n, &ch) == 1 && n < 16)
451 c = GetChannelIdxByName(device->RealOut, Aux0+n);
452 else
453 {
454 ERR("AmbDec speaker label \"%s\" not recognized\n", name);
455 return false;
456 }
457 }
458 if(c == -1)
459 {
460 ERR("Failed to lookup AmbDec speaker label %s\n",
461 al_string_get_cstr(conf->Speakers[i].Name));
462 return false;
463 }
464 speakermap[i] = c;
465 }
466
467 return true;
468 }
469
470
471 /* NOTE: These decoder coefficients are using FuMa channel ordering and
472 * normalization, since that's what was produced by the Ambisonic Decoder
473 * Toolbox. SetChannelMap will convert them to N3D.
474 */
475 static const ChannelMap MonoCfg[1] = {
476 { FrontCenter, { 1.414213562f } },
477 }, StereoCfg[2] = {
478 { FrontLeft, { 0.707106781f, 0.0f, 0.5f, 0.0f } },
479 { FrontRight, { 0.707106781f, 0.0f, -0.5f, 0.0f } },
480 }, QuadCfg[4] = {
481 { FrontLeft, { 0.353553f, 0.306186f, 0.306186f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f, 0.125000f } },
482 { FrontRight, { 0.353553f, 0.306186f, -0.306186f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f, -0.125000f } },
483 { BackLeft, { 0.353553f, -0.306186f, 0.306186f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f, -0.125000f } },
484 { BackRight, { 0.353553f, -0.306186f, -0.306186f, 0.0f, 0.0f, 0.0f, 0.0f, 0.000000f, 0.125000f } },
485 }, X51SideCfg[5] = {
486 { FrontLeft, { 0.208954f, 0.199518f, 0.223424f, 0.0f, 0.0f, 0.0f, 0.0f, -0.012543f, 0.144260f } },
487 { FrontRight, { 0.208950f, 0.199514f, -0.223425f, 0.0f, 0.0f, 0.0f, 0.0f, -0.012544f, -0.144258f } },
488 { FrontCenter, { 0.109403f, 0.168250f, -0.000002f, 0.0f, 0.0f, 0.0f, 0.0f, 0.100431f, -0.000001f } },
489 { SideLeft, { 0.470934f, -0.346484f, 0.327504f, 0.0f, 0.0f, 0.0f, 0.0f, -0.022188f, -0.041113f } },
490 { SideRight, { 0.470936f, -0.346480f, -0.327507f, 0.0f, 0.0f, 0.0f, 0.0f, -0.022186f, 0.041114f } },
491 }, X51RearCfg[5] = {
492 { FrontLeft, { 0.208954f, 0.199518f, 0.223424f, 0.0f, 0.0f, 0.0f, 0.0f, -0.012543f, 0.144260f } },
493 { FrontRight, { 0.208950f, 0.199514f, -0.223425f, 0.0f, 0.0f, 0.0f, 0.0f, -0.012544f, -0.144258f } },
494 { FrontCenter, { 0.109403f, 0.168250f, -0.000002f, 0.0f, 0.0f, 0.0f, 0.0f, 0.100431f, -0.000001f } },
495 { BackLeft, { 0.470934f, -0.346484f, 0.327504f, 0.0f, 0.0f, 0.0f, 0.0f, -0.022188f, -0.041113f } },
496 { BackRight, { 0.470936f, -0.346480f, -0.327507f, 0.0f, 0.0f, 0.0f, 0.0f, -0.022186f, 0.041114f } },
497 }, X61Cfg[6] = {
498 { 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 } },
499 { 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 } },
500 { 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 } },
501 { 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 } },
502 { 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 } },
503 { 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 } },
504 }, X71Cfg[7] = {
505 { 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 } },
506 { 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 } },
507 { 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 } },
508 { 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 } },
509 { 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 } },
510 { 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 } },
511 { 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 } },
512 };
513
514 static void InitPanning(ALCdevice *device)
515 {
516 const ChannelMap *chanmap = NULL;
517 ALuint coeffcount = 0;
518 ALfloat ambiscale;
519 size_t count = 0;
520 ALuint i, j;
521
522 ambiscale = 1.0f;
523 switch(device->FmtChans)
524 {
525 case DevFmtMono:
526 count = COUNTOF(MonoCfg);
527 chanmap = MonoCfg;
528 ambiscale = ZERO_ORDER_SCALE;
529 coeffcount = 1;
530 break;
531
532 case DevFmtStereo:
533 count = COUNTOF(StereoCfg);
534 chanmap = StereoCfg;
535 ambiscale = FIRST_ORDER_SCALE;
536 coeffcount = 4;
537 break;
538
539 case DevFmtQuad:
540 count = COUNTOF(QuadCfg);
541 chanmap = QuadCfg;
542 ambiscale = SECOND_ORDER_SCALE;
543 coeffcount = 9;
544 break;
545
546 case DevFmtX51:
547 count = COUNTOF(X51SideCfg);
548 chanmap = X51SideCfg;
549 ambiscale = SECOND_ORDER_SCALE;
550 coeffcount = 9;
551 break;
552
553 case DevFmtX51Rear:
554 count = COUNTOF(X51RearCfg);
555 chanmap = X51RearCfg;
556 ambiscale = SECOND_ORDER_SCALE;
557 coeffcount = 9;
558 break;
559
560 case DevFmtX61:
561 count = COUNTOF(X61Cfg);
562 chanmap = X61Cfg;
563 ambiscale = THIRD_ORDER_SCALE;
564 coeffcount = 16;
565 break;
566
567 case DevFmtX71:
568 count = COUNTOF(X71Cfg);
569 chanmap = X71Cfg;
570 ambiscale = THIRD_ORDER_SCALE;
571 coeffcount = 16;
572 break;
573
574 case DevFmtAmbi1:
575 case DevFmtAmbi2:
576 case DevFmtAmbi3:
577 break;
578 }
579
580 if(device->FmtChans >= DevFmtAmbi1 && device->FmtChans <= DevFmtAmbi3)
581 {
582 const ALuint *acnmap = (device->AmbiFmt == AmbiFormat_FuMa) ? FuMa2ACN : ACN2ACN;
583 const ALfloat *n3dscale = (device->AmbiFmt == AmbiFormat_FuMa) ? FuMa2N3DScale :
584 (device->AmbiFmt == AmbiFormat_ACN_SN3D) ? SN3D2N3DScale :
585 /*(device->AmbiFmt == AmbiFormat_ACN_N3D) ?*/ UnitScale;
586
587 count = (device->FmtChans == DevFmtAmbi3) ? 16 :
588 (device->FmtChans == DevFmtAmbi2) ? 9 :
589 (device->FmtChans == DevFmtAmbi1) ? 4 : 1;
590 for(i = 0;i < count;i++)
591 {
592 ALuint acn = acnmap[i];
593 device->Dry.Ambi.Map[i].Scale = 1.0f/n3dscale[acn];
594 device->Dry.Ambi.Map[i].Index = acn;
595 }
596 device->Dry.CoeffCount = 0;
597 device->Dry.NumChannels = count;
598
599 if(device->FmtChans == DevFmtAmbi1)
600 {
601 device->FOAOut.Ambi = device->Dry.Ambi;
602 device->FOAOut.CoeffCount = device->Dry.CoeffCount;
603 }
604 else
605 {
606 /* FOA output is always ACN+N3D for higher-order ambisonic output.
607 * The upsampler expects this and will convert it for output.
608 */
609 memset(&device->FOAOut.Ambi, 0, sizeof(device->FOAOut.Ambi));
610 for(i = 0;i < 4;i++)
611 {
612 device->FOAOut.Ambi.Map[i].Scale = 1.0f;
613 device->FOAOut.Ambi.Map[i].Index = i;
614 }
615 device->FOAOut.CoeffCount = 0;
616
617 ambiup_reset(device->AmbiUp, device);
618 }
619 }
620 else
621 {
622 SetChannelMap(device->RealOut.ChannelName, device->Dry.Ambi.Coeffs,
623 chanmap, count, &device->Dry.NumChannels, AL_TRUE);
624 device->Dry.CoeffCount = coeffcount;
625
626 memset(&device->FOAOut.Ambi, 0, sizeof(device->FOAOut.Ambi));
627 for(i = 0;i < device->Dry.NumChannels;i++)
628 {
629 device->FOAOut.Ambi.Coeffs[i][0] = device->Dry.Ambi.Coeffs[i][0];
630 for(j = 1;j < 4;j++)
631 device->FOAOut.Ambi.Coeffs[i][j] = device->Dry.Ambi.Coeffs[i][j] * ambiscale;
632 }
633 device->FOAOut.CoeffCount = 4;
634 }
635 }
636
637 static void InitCustomPanning(ALCdevice *device, const AmbDecConf *conf, const ALuint speakermap[MAX_OUTPUT_CHANNELS])
638 {
639 ChannelMap chanmap[MAX_OUTPUT_CHANNELS];
640 const ALfloat *coeff_scale = UnitScale;
641 ALfloat ambiscale = 1.0f;
642 ALuint i, j;
643
644 if(conf->FreqBands != 1)
645 ERR("Basic renderer uses the high-frequency matrix as single-band (xover_freq = %.0fhz)\n",
646 conf->XOverFreq);
647
648 if(conf->ChanMask > 0x1ff)
649 ambiscale = THIRD_ORDER_SCALE;
650 else if(conf->ChanMask > 0xf)
651 ambiscale = SECOND_ORDER_SCALE;
652 else if(conf->ChanMask > 0x1)
653 ambiscale = FIRST_ORDER_SCALE;
654 else
655 ambiscale = 0.0f;
656
657 if(conf->CoeffScale == ADS_SN3D)
658 coeff_scale = SN3D2N3DScale;
659 else if(conf->CoeffScale == ADS_FuMa)
660 coeff_scale = FuMa2N3DScale;
661
662 for(i = 0;i < conf->NumSpeakers;i++)
663 {
664 ALuint chan = speakermap[i];
665 ALfloat gain;
666 ALuint k = 0;
667
668 for(j = 0;j < MAX_AMBI_COEFFS;j++)
669 chanmap[i].Config[j] = 0.0f;
670
671 chanmap[i].ChanName = device->RealOut.ChannelName[chan];
672 for(j = 0;j < MAX_AMBI_COEFFS;j++)
673 {
674 if(j == 0) gain = conf->HFOrderGain[0];
675 else if(j == 1) gain = conf->HFOrderGain[1];
676 else if(j == 4) gain = conf->HFOrderGain[2];
677 else if(j == 9) gain = conf->HFOrderGain[3];
678 if((conf->ChanMask&(1<<j)))
679 chanmap[i].Config[j] = conf->HFMatrix[i][k++] / coeff_scale[j] * gain;
680 }
681 }
682
683 SetChannelMap(device->RealOut.ChannelName, device->Dry.Ambi.Coeffs, chanmap,
684 conf->NumSpeakers, &device->Dry.NumChannels, AL_FALSE);
685 device->Dry.CoeffCount = (conf->ChanMask > 0x1ff) ? 16 :
686 (conf->ChanMask > 0xf) ? 9 : 4;
687
688 memset(&device->FOAOut.Ambi, 0, sizeof(device->FOAOut.Ambi));
689 for(i = 0;i < device->Dry.NumChannels;i++)
690 {
691 device->FOAOut.Ambi.Coeffs[i][0] = device->Dry.Ambi.Coeffs[i][0];
692 for(j = 1;j < 4;j++)
693 device->FOAOut.Ambi.Coeffs[i][j] = device->Dry.Ambi.Coeffs[i][j] * ambiscale;
694 }
695 device->FOAOut.CoeffCount = 4;
696 }
697
698 static void InitHQPanning(ALCdevice *device, const AmbDecConf *conf, const ALuint speakermap[MAX_OUTPUT_CHANNELS])
699 {
700 const char *devname;
701 int decflags = 0;
702 size_t count;
703 ALuint i;
704
705 devname = al_string_get_cstr(device->DeviceName);
706 if(GetConfigValueBool(devname, "decoder", "distance-comp", 1))
707 decflags |= BFDF_DistanceComp;
708
709 if((conf->ChanMask&AMBI_PERIPHONIC_MASK))
710 {
711 count = (conf->ChanMask > 0x1ff) ? 16 :
712 (conf->ChanMask > 0xf) ? 9 : 4;
713 for(i = 0;i < count;i++)
714 {
715 device->Dry.Ambi.Map[i].Scale = 1.0f;
716 device->Dry.Ambi.Map[i].Index = i;
717 }
718 }
719 else
720 {
721 static const int map[MAX_AMBI2D_COEFFS] = { 0, 1, 3, 4, 8, 9, 15 };
722
723 count = (conf->ChanMask > 0x1ff) ? 7 :
724 (conf->ChanMask > 0xf) ? 5 : 3;
725 for(i = 0;i < count;i++)
726 {
727 device->Dry.Ambi.Map[i].Scale = 1.0f;
728 device->Dry.Ambi.Map[i].Index = map[i];
729 }
730 }
731 device->Dry.CoeffCount = 0;
732 device->Dry.NumChannels = count;
733
734 TRACE("Enabling %s-band %s-order%s ambisonic decoder\n",
735 (conf->FreqBands == 1) ? "single" : "dual",
736 (conf->ChanMask > 0xf) ? (conf->ChanMask > 0x1ff) ? "third" : "second" : "first",
737 (conf->ChanMask&AMBI_PERIPHONIC_MASK) ? " periphonic" : ""
738 );
739 bformatdec_reset(device->AmbiDecoder, conf, count, device->Frequency,
740 speakermap, decflags);
741
742 if(bformatdec_getOrder(device->AmbiDecoder) < 2)
743 {
744 device->FOAOut.Ambi = device->Dry.Ambi;
745 device->FOAOut.CoeffCount = device->Dry.CoeffCount;
746 }
747 else
748 {
749 memset(&device->FOAOut.Ambi, 0, sizeof(device->FOAOut.Ambi));
750 for(i = 0;i < 4;i++)
751 {
752 device->FOAOut.Ambi.Map[i].Scale = 1.0f;
753 device->FOAOut.Ambi.Map[i].Index = i;
754 }
755 device->FOAOut.CoeffCount = 0;
756 }
757 }
758
759 static void InitHrtfPanning(ALCdevice *device)
760 {
761 size_t count = 4;
762 ALuint i;
763
764 for(i = 0;i < count;i++)
765 {
766 device->Dry.Ambi.Map[i].Scale = 1.0f;
767 device->Dry.Ambi.Map[i].Index = i;
768 }
769 device->Dry.CoeffCount = 0;
770 device->Dry.NumChannels = count;
771
772 device->FOAOut.Ambi = device->Dry.Ambi;
773 device->FOAOut.CoeffCount = device->Dry.CoeffCount;
774
775 memset(device->Hrtf_Coeffs, 0, sizeof(device->Hrtf_Coeffs));
776 device->Hrtf_IrSize = BuildBFormatHrtf(device->Hrtf, device->Hrtf_Coeffs,
777 device->Dry.NumChannels);
778
779 /* Round up to the nearest multiple of 8 */
780 device->Hrtf_IrSize = (device->Hrtf_IrSize+7)&~7;
781 }
782
783 static void InitUhjPanning(ALCdevice *device)
784 {
785 size_t count = 3;
786 ALuint i;
787
788 for(i = 0;i < count;i++)
789 {
790 ALuint acn = FuMa2ACN[i];
791 device->Dry.Ambi.Map[i].Scale = 1.0f/FuMa2N3DScale[acn];
792 device->Dry.Ambi.Map[i].Index = acn;
793 }
794 device->Dry.CoeffCount = 0;
795 device->Dry.NumChannels = count;
796
797 device->FOAOut.Ambi = device->Dry.Ambi;
798 device->FOAOut.CoeffCount = device->Dry.CoeffCount;
799 }
800
801 void aluInitRenderer(ALCdevice *device, ALint hrtf_id, enum HrtfRequestMode hrtf_appreq, enum HrtfRequestMode hrtf_userreq)
802 {
803 const char *mode;
804 bool headphones;
805 int bs2blevel;
806 size_t i;
807
808 device->Hrtf = NULL;
809 al_string_clear(&device->Hrtf_Name);
810 device->Render_Mode = NormalRender;
811
812 memset(&device->Dry.Ambi, 0, sizeof(device->Dry.Ambi));
813 device->Dry.CoeffCount = 0;
814 device->Dry.NumChannels = 0;
815
816 if(device->FmtChans != DevFmtStereo)
817 {
818 ALuint speakermap[MAX_OUTPUT_CHANNELS];
819 const char *devname, *layout = NULL;
820 AmbDecConf conf, *pconf = NULL;
821
822 if(hrtf_appreq == Hrtf_Enable)
823 device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
824
825 ambdec_init(&conf);
826
827 devname = al_string_get_cstr(device->DeviceName);
828 switch(device->FmtChans)
829 {
830 case DevFmtQuad: layout = "quad"; break;
831 case DevFmtX51: layout = "surround51"; break;
832 case DevFmtX51Rear: layout = "surround51rear"; break;
833 case DevFmtX61: layout = "surround61"; break;
834 case DevFmtX71: layout = "surround71"; break;
835 /* Mono, Stereo, and Ambisonics output don't use custom decoders. */
836 case DevFmtMono:
837 case DevFmtStereo:
838 case DevFmtAmbi1:
839 case DevFmtAmbi2:
840 case DevFmtAmbi3:
841 break;
842 }
843 if(layout)
844 {
845 const char *fname;
846 if(ConfigValueStr(devname, "decoder", layout, &fname))
847 {
848 if(!ambdec_load(&conf, fname))
849 ERR("Failed to load layout file %s\n", fname);
850 else
851 {
852 if(conf.ChanMask > 0xffff)
853 ERR("Unsupported channel mask 0x%04x (max 0xffff)\n", conf.ChanMask);
854 else
855 {
856 if(MakeSpeakerMap(device, &conf, speakermap))
857 pconf = &conf;
858 }
859 }
860 }
861 }
862
863 if(pconf && GetConfigValueBool(devname, "decoder", "hq-mode", 0))
864 {
865 ambiup_free(device->AmbiUp);
866 device->AmbiUp = NULL;
867 if(!device->AmbiDecoder)
868 device->AmbiDecoder = bformatdec_alloc();
869 }
870 else
871 {
872 bformatdec_free(device->AmbiDecoder);
873 device->AmbiDecoder = NULL;
874 if(device->FmtChans > DevFmtAmbi1 && device->FmtChans <= DevFmtAmbi3)
875 {
876 if(!device->AmbiUp)
877 device->AmbiUp = ambiup_alloc();
878 }
879 else
880 {
881 ambiup_free(device->AmbiUp);
882 device->AmbiUp = NULL;
883 }
884 }
885
886 if(!pconf)
887 InitPanning(device);
888 else if(device->AmbiDecoder)
889 InitHQPanning(device, pconf, speakermap);
890 else
891 InitCustomPanning(device, pconf, speakermap);
892
893 ambdec_deinit(&conf);
894 return;
895 }
896
897 ambiup_free(device->AmbiUp);
898 device->AmbiUp = NULL;
899 bformatdec_free(device->AmbiDecoder);
900 device->AmbiDecoder = NULL;
901
902 headphones = device->IsHeadphones;
903 if(device->Type != Loopback)
904 {
905 const char *mode;
906 if(ConfigValueStr(al_string_get_cstr(device->DeviceName), NULL, "stereo-mode", &mode))
907 {
908 if(strcasecmp(mode, "headphones") == 0)
909 headphones = true;
910 else if(strcasecmp(mode, "speakers") == 0)
911 headphones = false;
912 else if(strcasecmp(mode, "auto") != 0)
913 ERR("Unexpected stereo-mode: %s\n", mode);
914 }
915 }
916
917 if(hrtf_userreq == Hrtf_Default)
918 {
919 bool usehrtf = (headphones && hrtf_appreq != Hrtf_Disable) ||
920 (hrtf_appreq == Hrtf_Enable);
921 if(!usehrtf) goto no_hrtf;
922
923 device->Hrtf_Status = ALC_HRTF_ENABLED_SOFT;
924 if(headphones && hrtf_appreq != Hrtf_Disable)
925 device->Hrtf_Status = ALC_HRTF_HEADPHONES_DETECTED_SOFT;
926 }
927 else
928 {
929 if(hrtf_userreq != Hrtf_Enable)
930 {
931 if(hrtf_appreq == Hrtf_Enable)
932 device->Hrtf_Status = ALC_HRTF_DENIED_SOFT;
933 goto no_hrtf;
934 }
935 device->Hrtf_Status = ALC_HRTF_REQUIRED_SOFT;
936 }
937
938 if(VECTOR_SIZE(device->Hrtf_List) == 0)
939 {
940 VECTOR_DEINIT(device->Hrtf_List);
941 device->Hrtf_List = EnumerateHrtf(device->DeviceName);
942 }
943
944 if(hrtf_id >= 0 && (size_t)hrtf_id < VECTOR_SIZE(device->Hrtf_List))
945 {
946 const HrtfEntry *entry = &VECTOR_ELEM(device->Hrtf_List, hrtf_id);
947 if(entry->hrtf->sampleRate == device->Frequency)
948 {
949 device->Hrtf = entry->hrtf;
950 al_string_copy(&device->Hrtf_Name, entry->name);
951 }
952 }
953
954 for(i = 0;!device->Hrtf && i < VECTOR_SIZE(device->Hrtf_List);i++)
955 {
956 const HrtfEntry *entry = &VECTOR_ELEM(device->Hrtf_List, i);
957 if(entry->hrtf->sampleRate == device->Frequency)
958 {
959 device->Hrtf = entry->hrtf;
960 al_string_copy(&device->Hrtf_Name, entry->name);
961 }
962 }
963
964 if(device->Hrtf)
965 {
966 device->Render_Mode = HrtfRender;
967 if(ConfigValueStr(al_string_get_cstr(device->DeviceName), NULL, "hrtf-mode", &mode))
968 {
969 if(strcasecmp(mode, "full") == 0)
970 device->Render_Mode = HrtfRender;
971 else if(strcasecmp(mode, "basic") == 0)
972 device->Render_Mode = NormalRender;
973 else
974 ERR("Unexpected hrtf-mode: %s\n", mode);
975 }
976
977 TRACE("HRTF enabled, \"%s\"\n", al_string_get_cstr(device->Hrtf_Name));
978 InitHrtfPanning(device);
979 return;
980 }
981 device->Hrtf_Status = ALC_HRTF_UNSUPPORTED_FORMAT_SOFT;
982
983 no_hrtf:
984 TRACE("HRTF disabled\n");
985
986 bs2blevel = ((headphones && hrtf_appreq != Hrtf_Disable) ||
987 (hrtf_appreq == Hrtf_Enable)) ? 5 : 0;
988 if(device->Type != Loopback)
989 ConfigValueInt(al_string_get_cstr(device->DeviceName), NULL, "cf_level", &bs2blevel);
990 if(bs2blevel > 0 && bs2blevel <= 6)
991 {
992 device->Bs2b = al_calloc(16, sizeof(*device->Bs2b));
993 bs2b_set_params(device->Bs2b, bs2blevel, device->Frequency);
994 device->Render_Mode = StereoPair;
995 TRACE("BS2B enabled\n");
996 InitPanning(device);
997 return;
998 }
999
1000 TRACE("BS2B disabled\n");
1001
1002 device->Render_Mode = NormalRender;
1003 if(ConfigValueStr(al_string_get_cstr(device->DeviceName), NULL, "stereo-panning", &mode))
1004 {
1005 if(strcasecmp(mode, "paired") == 0)
1006 device->Render_Mode = StereoPair;
1007 else if(strcasecmp(mode, "uhj") != 0)
1008 ERR("Unexpected stereo-panning: %s\n", mode);
1009 }
1010 if(device->Render_Mode == NormalRender)
1011 {
1012 device->Uhj_Encoder = al_calloc(16, sizeof(Uhj2Encoder));
1013 TRACE("UHJ enabled\n");
1014 InitUhjPanning(device);
1015 return;
1016 }
1017
1018 TRACE("UHJ disabled\n");
1019 InitPanning(device);
1020 }
1021
1022
1023 void aluInitEffectPanning(ALeffectslot *slot)
1024 {
1025 ALuint i;
1026
1027 memset(slot->ChanMap, 0, sizeof(slot->ChanMap));
1028 slot->NumChannels = 0;
1029
1030 for(i = 0;i < MAX_EFFECT_CHANNELS;i++)
1031 {
1032 slot->ChanMap[i].Scale = 1.0f;
1033 slot->ChanMap[i].Index = i;
1034 }
1035 slot->NumChannels = i;
1036 }
Software OpenAL implementation