Mercurial > mplayer.hg
comparison libaf/af_hrtf.c @ 15082:71570687c1a3
HRTF filter updates:
- Bass compensation gain corrected (which was set too low), now the
sound should be even more transparent
- A (unified) dual axes active matrix decoder with adaptive steering
- capable of decoding matrix surround encoded inputs, with stereo rear
- capable of decoding matrix encoded rear center
- Purely stereo mixing without unneccessary rear filter calculations
- The decoding structure message is moved, because at the old place it
gave incorrect messages.
Patch by Yue Shi Lai <ylai@users.sourceforge.net>
author | henry |
---|---|
date | Sun, 10 Apr 2005 08:47:16 +0000 |
parents | 0a22a046f0d3 |
children | e267fad254fb |
comparison
equal
deleted
inserted
replaced
15081:2e628bcd6dd5 | 15082:71570687c1a3 |
---|---|
26 /* Bass */ | 26 /* Bass */ |
27 float *ba_l, *ba_r; | 27 float *ba_l, *ba_r; |
28 float *ba_ir; | 28 float *ba_ir; |
29 /* Whether to matrix decode the rear center channel */ | 29 /* Whether to matrix decode the rear center channel */ |
30 int matrix_mode; | 30 int matrix_mode; |
31 /* Full wave rectified amplitude used to steer the active matrix | 31 /* How to decode the input: |
32 decoding of center rear channel */ | 32 0 = 5/5+1 channels |
33 float lr_fwr, rr_fwr; | 33 1 = 2 channels |
34 2 = matrix encoded 2 channels */ | |
35 int decode_mode; | |
36 /* Full wave rectified (FWR) amplitudes and gain used to steer the | |
37 active matrix decoding of front channels (variable names | |
38 lpr/lmr means Lt + Rt, Lt - Rt) */ | |
39 float l_fwr, r_fwr, lpr_fwr, lmr_fwr; | |
40 float adapt_l_gain, adapt_r_gain, adapt_lpr_gain, adapt_lmr_gain; | |
41 /* Matrix input decoding require special FWR buffer, since the | |
42 decoding is done in place. */ | |
43 float *fwrbuf_l, *fwrbuf_r, *fwrbuf_lr, *fwrbuf_rr; | |
44 /* Rear channel delay buffer for matrix decoding */ | |
45 float *rear_dlbuf; | |
46 /* Full wave rectified amplitude and gain used to steer the active | |
47 matrix decoding of center rear channel */ | |
48 float lr_fwr, rr_fwr, lrprr_fwr, lrmrr_fwr; | |
49 float adapt_lr_gain, adapt_rr_gain; | |
50 float adapt_lrprr_gain, adapt_lrmrr_gain; | |
34 /* Cyclic position on the ring buffer */ | 51 /* Cyclic position on the ring buffer */ |
35 int cyc_pos; | 52 int cyc_pos; |
53 int print_flag; | |
36 } af_hrtf_t; | 54 } af_hrtf_t; |
37 | 55 |
38 /* Convolution on a ring buffer | 56 /* Convolution on a ring buffer |
39 * nx: length of the ring buffer | 57 * nx: length of the ring buffer |
40 * nk: length of the convolution kernel | 58 * nk: length of the convolution kernel |
68 if(fabs(sx[i]) > thresh) | 86 if(fabs(sx[i]) > thresh) |
69 return i; | 87 return i; |
70 return 0; | 88 return 0; |
71 } | 89 } |
72 | 90 |
91 /* Unified active matrix decoder for 2 channel matrix encoded surround | |
92 sources */ | |
93 inline void matrix_decode(short *in, const int k, const int il, | |
94 const int ir, const int decode_rear, | |
95 const int dlbuflen, | |
96 float l_fwr, float r_fwr, | |
97 float lpr_fwr, float lmr_fwr, | |
98 float *adapt_l_gain, float *adapt_r_gain, | |
99 float *adapt_lpr_gain, float *adapt_lmr_gain, | |
100 float *lf, float *rf, float *lr, | |
101 float *rr, float *cf) | |
102 { | |
103 const int kr = (k + MATREARDELAY) % dlbuflen; | |
104 float l_gain = (l_fwr + r_fwr) / | |
105 (1 + l_fwr + l_fwr); | |
106 float r_gain = (l_fwr + r_fwr) / | |
107 (1 + r_fwr + r_fwr); | |
108 float lpr_gain = (lpr_fwr + lmr_fwr) / | |
109 (1 + lpr_fwr + lpr_fwr); | |
110 float lmr_gain = (lpr_fwr + lmr_fwr) / | |
111 (1 + lmr_fwr + lmr_fwr); | |
112 float lpr, lmr; | |
113 float l_agc, r_agc, lpr_agc, lmr_agc; | |
114 float f, d_gain; | |
115 | |
116 #if 0 | |
117 static int counter = 0; | |
118 static FILE *fp_out; | |
119 | |
120 if(counter == 0) | |
121 fp_out = fopen("af_hrtf.log", "w"); | |
122 fprintf(fp_out, "%g %g %g %g %g ", counter * (1.0 / 48000), | |
123 l_gain, r_gain, lpr_gain, lmr_gain); | |
124 #endif | |
125 | |
126 /*** AXIS NO. 1: (Lt, Rt) -> (C, Ls, Rs) ***/ | |
127 /* AGC adaption */ | |
128 d_gain = (fabs(l_gain - *adapt_l_gain) + | |
129 fabs(r_gain - *adapt_r_gain)) * 0.5; | |
130 f = d_gain * (1.0 / MATAGCTRIG); | |
131 f = MATAGCDECAY - MATAGCDECAY / (1 + f * f); | |
132 *adapt_l_gain = (1 - f) * *adapt_l_gain + f * l_gain; | |
133 *adapt_r_gain = (1 - f) * *adapt_r_gain + f * r_gain; | |
134 /* Matrix */ | |
135 l_agc = in[il] * *adapt_l_gain; | |
136 r_agc = in[ir] * *adapt_r_gain; | |
137 cf[k] = (l_agc + r_agc) * M_SQRT1_2; | |
138 if(decode_rear) { | |
139 lr[kr] = rr[kr] = (l_agc - r_agc) * M_SQRT1_2; | |
140 /* Stereo rear channel is steered with the same AGC steering as | |
141 the decoding matrix. Note this requires a fast updating AGC | |
142 at the order of 20 ms (which is the case here). */ | |
143 lr[kr] *= (l_fwr + l_fwr) / | |
144 (1 + l_fwr + r_fwr); | |
145 rr[kr] *= (r_fwr + r_fwr) / | |
146 (1 + l_fwr + r_fwr); | |
147 } | |
148 | |
149 /*** AXIS NO. 2: (Lt + Rt, Lt - Rt) -> (L, R) ***/ | |
150 lpr = (in[il] + in[ir]) * M_SQRT1_2; | |
151 lmr = (in[il] - in[ir]) * M_SQRT1_2; | |
152 /* AGC adaption */ | |
153 d_gain = (fabs(lpr_gain - *adapt_lpr_gain) + | |
154 fabs(lmr_gain - *adapt_lmr_gain)) * 0.5; | |
155 f = d_gain * (1.0 / MATAGCTRIG); | |
156 f = MATAGCDECAY - MATAGCDECAY / (1 + f * f); | |
157 *adapt_lpr_gain = (1 - f) * *adapt_lpr_gain + f * lpr_gain; | |
158 *adapt_lmr_gain = (1 - f) * *adapt_lmr_gain + f * lmr_gain; | |
159 /* The 2nd axis has strong gain fluctuations, and therefore require | |
160 limits. The factor is tricky. I think 2 is the reasonable | |
161 value here, which phase inverts the L, R channel if Lt, Rt is | |
162 strongly correlated (e.g. during dialogues) (1 would inhibit the | |
163 steering behavior, > 4 appears to result in distortions). */ | |
164 if(*adapt_lmr_gain > 2 * *adapt_lpr_gain) | |
165 *adapt_lmr_gain = 2 * *adapt_lpr_gain; | |
166 /* Matrix */ | |
167 lpr_agc = lpr * *adapt_lpr_gain; | |
168 lmr_agc = lmr * *adapt_lmr_gain; | |
169 lf[k] = (lpr_agc + lmr_agc) * M_SQRT1_2; | |
170 rf[k] = (lpr_agc - lmr_agc) * M_SQRT1_2; | |
171 | |
172 #if 0 | |
173 fprintf(fp_out, "%g %g %g %g\n", | |
174 *adapt_l_gain, *adapt_r_gain, | |
175 *adapt_lpr_gain, *adapt_lmr_gain); | |
176 counter++; | |
177 #endif | |
178 } | |
179 | |
73 inline void update_ch(af_hrtf_t *s, short *in, const int k) | 180 inline void update_ch(af_hrtf_t *s, short *in, const int k) |
74 { | 181 { |
75 /* Update the full wave rectified total amplutude */ | 182 const int fwr_pos = (k + FWRDURATION) % s->dlbuflen; |
76 s->lr_fwr += abs(in[2]) - fabs(s->lr[k]); | 183 /* Update the full wave rectified total amplitude */ |
77 s->rr_fwr += abs(in[3]) - fabs(s->rr[k]); | 184 /* Input matrix decoder */ |
78 | 185 if(s->decode_mode == HRTF_MIX_MATRIX2CH) { |
79 s->lf[k] = in[0]; | 186 s->l_fwr += abs(in[0]) - fabs(s->fwrbuf_l[fwr_pos]); |
80 s->cf[k] = in[4]; | 187 s->r_fwr += abs(in[1]) - fabs(s->fwrbuf_r[fwr_pos]); |
81 s->rf[k] = in[1]; | 188 s->lpr_fwr += abs(in[0] + in[1]) - |
82 s->lr[k] = in[2]; | 189 fabs(s->fwrbuf_l[fwr_pos] + s->fwrbuf_r[fwr_pos]); |
83 s->rr[k] = in[3]; | 190 s->lmr_fwr += abs(in[0] - in[1]) - |
84 | 191 fabs(s->fwrbuf_l[fwr_pos] - s->fwrbuf_r[fwr_pos]); |
192 } | |
193 /* Rear matrix decoder */ | |
194 if(s->matrix_mode) { | |
195 s->lr_fwr += abs(in[2]) - fabs(s->fwrbuf_lr[fwr_pos]); | |
196 s->rr_fwr += abs(in[3]) - fabs(s->fwrbuf_rr[fwr_pos]); | |
197 s->lrprr_fwr += abs(in[2] + in[3]) - | |
198 fabs(s->fwrbuf_lr[fwr_pos] + s->fwrbuf_rr[fwr_pos]); | |
199 s->lrmrr_fwr += abs(in[2] - in[3]) - | |
200 fabs(s->fwrbuf_lr[fwr_pos] - s->fwrbuf_rr[fwr_pos]); | |
201 } | |
202 | |
203 switch (s->decode_mode) { | |
204 case HRTF_MIX_51: | |
205 /* 5/5+1 channel sources */ | |
206 s->lf[k] = in[0]; | |
207 s->cf[k] = in[4]; | |
208 s->rf[k] = in[1]; | |
209 s->fwrbuf_lr[k] = s->lr[k] = in[2]; | |
210 s->fwrbuf_rr[k] = s->rr[k] = in[3]; | |
211 break; | |
212 case HRTF_MIX_MATRIX2CH: | |
213 /* Matrix encoded 2 channel sources */ | |
214 s->fwrbuf_l[k] = in[0]; | |
215 s->fwrbuf_r[k] = in[1]; | |
216 matrix_decode(in, k, 0, 1, 1, s->dlbuflen, | |
217 s->l_fwr, s->r_fwr, | |
218 s->lpr_fwr, s->lmr_fwr, | |
219 &(s->adapt_l_gain), &(s->adapt_r_gain), | |
220 &(s->adapt_lpr_gain), &(s->adapt_lmr_gain), | |
221 s->lf, s->rf, s->lr, s->rr, s->cf); | |
222 break; | |
223 case HRTF_MIX_STEREO: | |
224 /* Stereo sources */ | |
225 s->lf[k] = in[0]; | |
226 s->rf[k] = in[1]; | |
227 s->cf[k] = s->lr[k] = s->rr[k] = 0; | |
228 break; | |
229 } | |
230 | |
231 /* We need to update the bass compensation delay line, too. */ | |
85 s->ba_l[k] = in[0] + in[4] + in[2]; | 232 s->ba_l[k] = in[0] + in[4] + in[2]; |
86 s->ba_r[k] = in[4] + in[1] + in[3]; | 233 s->ba_r[k] = in[4] + in[1] + in[3]; |
87 } | |
88 | |
89 inline void matrix_decode_cr(af_hrtf_t *s, short *in, const int k) | |
90 { | |
91 /* Active matrix decoding of the center rear channel, 1 in the | |
92 denominator is to prevent singularity */ | |
93 float lr_agc = in[2] * (s->lr_fwr + s->rr_fwr) / | |
94 (1 + s->lr_fwr + s->lr_fwr); | |
95 float rr_agc = in[3] * (s->lr_fwr + s->rr_fwr) / | |
96 (1 + s->rr_fwr + s->rr_fwr); | |
97 | |
98 s->cr[k] = (lr_agc + rr_agc) * M_SQRT1_2; | |
99 } | 234 } |
100 | 235 |
101 /* Initialization and runtime control */ | 236 /* Initialization and runtime control */ |
102 static int control(struct af_instance_s *af, int cmd, void* arg) | 237 static int control(struct af_instance_s *af, int cmd, void* arg) |
103 { | 238 { |
116 return AF_ERROR; | 251 return AF_ERROR; |
117 } | 252 } |
118 af->data->nch = ((af_data_t*)arg)->nch; | 253 af->data->nch = ((af_data_t*)arg)->nch; |
119 if(af->data->nch < 5) { | 254 if(af->data->nch < 5) { |
120 af->data->nch = 5; | 255 af->data->nch = 5; |
256 if(af->data->nch == 2) { | |
257 /* 2 channel input */ | |
258 if(s->decode_mode != HRTF_MIX_MATRIX2CH) { | |
259 /* Default behavior is stereo mixing. */ | |
260 s->decode_mode = HRTF_MIX_STEREO; | |
261 } | |
262 } | |
121 } | 263 } |
122 af->data->format = AF_FORMAT_S16_NE; | 264 af->data->format = AF_FORMAT_S16_NE; |
123 af->data->bps = 2; | 265 af->data->bps = 2; |
266 s->print_flag = 1; | |
124 return af_test_output(af, (af_data_t*)arg); | 267 return af_test_output(af, (af_data_t*)arg); |
125 case AF_CONTROL_COMMAND_LINE: | 268 case AF_CONTROL_COMMAND_LINE: |
126 sscanf((char*)arg, "%c", &mode); | 269 sscanf((char*)arg, "%c", &mode); |
127 switch(mode) { | 270 switch(mode) { |
128 case 'm': | 271 case 'm': |
272 /* Use matrix rear decoding. */ | |
129 s->matrix_mode = 1; | 273 s->matrix_mode = 1; |
274 break; | |
275 case 's': | |
276 /* Input needs matrix decoding. */ | |
277 s->decode_mode = HRTF_MIX_MATRIX2CH; | |
130 break; | 278 break; |
131 case '0': | 279 case '0': |
132 s->matrix_mode = 0; | 280 s->matrix_mode = 0; |
133 break; | 281 break; |
134 default: | 282 default: |
135 af_msg(AF_MSG_ERROR, | 283 af_msg(AF_MSG_ERROR, |
136 "[hrtf] Mode is neither 'm', nor '0' (%c).\n", | 284 "[hrtf] Mode is neither 'm', 's', nor '0' (%c).\n", |
137 mode); | 285 mode); |
138 return AF_ERROR; | 286 return AF_ERROR; |
139 } | 287 } |
288 s->print_flag = 1; | |
140 return AF_OK; | 289 return AF_OK; |
141 } | 290 } |
142 | |
143 af_msg(AF_MSG_INFO, | |
144 "[hrtf] Using HRTF to mix %s discrete surround into " | |
145 "L, R channels\n", s->matrix_mode ? "5" : "5+1"); | |
146 if(s->matrix_mode) | |
147 af_msg(AF_MSG_INFO, | |
148 "[hrtf] Using active matrix to decode rear center " | |
149 "channel\n"); | |
150 | 291 |
151 return AF_UNKNOWN; | 292 return AF_UNKNOWN; |
152 } | 293 } |
153 | 294 |
154 /* Deallocate memory */ | 295 /* Deallocate memory */ |
173 free(s->ba_l); | 314 free(s->ba_l); |
174 if(s->ba_r) | 315 if(s->ba_r) |
175 free(s->ba_r); | 316 free(s->ba_r); |
176 if(s->ba_ir) | 317 if(s->ba_ir) |
177 free(s->ba_ir); | 318 free(s->ba_ir); |
319 if(s->fwrbuf_l) | |
320 free(s->fwrbuf_l); | |
321 if(s->fwrbuf_r) | |
322 free(s->fwrbuf_r); | |
323 if(s->fwrbuf_lr) | |
324 free(s->fwrbuf_lr); | |
325 if(s->fwrbuf_rr) | |
326 free(s->fwrbuf_rr); | |
178 free(af->setup); | 327 free(af->setup); |
179 } | 328 } |
180 if(af->data) | 329 if(af->data) |
181 free(af->data); | 330 free(af->data); |
182 } | 331 } |
201 float common, left, right, diff, left_b, right_b; | 350 float common, left, right, diff, left_b, right_b; |
202 const int dblen = s->dlbuflen, hlen = s->hrflen, blen = s->basslen; | 351 const int dblen = s->dlbuflen, hlen = s->hrflen, blen = s->basslen; |
203 | 352 |
204 if(AF_OK != RESIZE_LOCAL_BUFFER(af, data)) | 353 if(AF_OK != RESIZE_LOCAL_BUFFER(af, data)) |
205 return NULL; | 354 return NULL; |
355 | |
356 if(s->print_flag) { | |
357 s->print_flag = 0; | |
358 switch (s->decode_mode) { | |
359 case HRTF_MIX_51: | |
360 af_msg(AF_MSG_INFO, | |
361 "[hrtf] Using HRTF to mix %s discrete surround into " | |
362 "L, R channels\n", s->matrix_mode ? "5+1" : "5"); | |
363 break; | |
364 case HRTF_MIX_STEREO: | |
365 af_msg(AF_MSG_INFO, | |
366 "[hrtf] Using HRTF to mix stereo into " | |
367 "L, R channels\n"); | |
368 break; | |
369 case HRTF_MIX_MATRIX2CH: | |
370 af_msg(AF_MSG_INFO, | |
371 "[hrtf] Using active matrix to decode 2 channel " | |
372 "input, HRTF to mix %s matrix surround into " | |
373 "L, R channels\n", "3/2"); | |
374 break; | |
375 default: | |
376 af_msg(AF_MSG_WARN, | |
377 "[hrtf] bogus decode_mode: %d\n", s->decode_mode); | |
378 break; | |
379 } | |
380 | |
381 if(s->matrix_mode) | |
382 af_msg(AF_MSG_INFO, | |
383 "[hrtf] Using active matrix to decode rear center " | |
384 "channel\n"); | |
385 } | |
206 | 386 |
207 out = af->data->audio; | 387 out = af->data->audio; |
208 | 388 |
209 /* MPlayer's 5 channel layout (notation for the variable): | 389 /* MPlayer's 5 channel layout (notation for the variable): |
210 * | 390 * |
234 psycho-acoustically "cheating" to focus the center front | 414 psycho-acoustically "cheating" to focus the center front |
235 channel, which is normally hard to be perceived as front */ | 415 channel, which is normally hard to be perceived as front */ |
236 s->lf[k] += CFECHOAMPL * s->cf[(k + CFECHODELAY) % s->dlbuflen]; | 416 s->lf[k] += CFECHOAMPL * s->cf[(k + CFECHODELAY) % s->dlbuflen]; |
237 s->rf[k] += CFECHOAMPL * s->cf[(k + CFECHODELAY) % s->dlbuflen]; | 417 s->rf[k] += CFECHOAMPL * s->cf[(k + CFECHODELAY) % s->dlbuflen]; |
238 | 418 |
239 /* Mixer filter matrix */ | 419 switch (s->decode_mode) { |
240 common = conv(dblen, hlen, s->cf, s->cf_ir, k + s->cf_o); | 420 case HRTF_MIX_51: |
241 if(s->matrix_mode) { | 421 case HRTF_MIX_MATRIX2CH: |
242 /* In matrix decoding mode, the rear channel gain must be | 422 /* Mixer filter matrix */ |
243 renormalized, as there is an additional channel. */ | 423 common = conv(dblen, hlen, s->cf, s->cf_ir, k + s->cf_o); |
244 matrix_decode_cr(s, in, k); | 424 if(s->matrix_mode) { |
245 common += | 425 /* In matrix decoding mode, the rear channel gain must be |
246 conv(dblen, hlen, s->cr, s->cr_ir, k + s->cr_o) * | 426 renormalized, as there is an additional channel. */ |
247 M1_76DB; | 427 matrix_decode(in, k, 2, 3, 0, s->dlbuflen, |
248 left = | 428 s->lr_fwr, s->rr_fwr, |
249 ( conv(dblen, hlen, s->lf, s->af_ir, k + s->af_o) + | 429 s->lrprr_fwr, s->lrmrr_fwr, |
250 conv(dblen, hlen, s->rf, s->of_ir, k + s->of_o) + | 430 &(s->adapt_lr_gain), &(s->adapt_rr_gain), |
251 (conv(dblen, hlen, s->lr, s->ar_ir, k + s->ar_o) + | 431 &(s->adapt_lrprr_gain), &(s->adapt_lrmrr_gain), |
252 conv(dblen, hlen, s->rr, s->or_ir, k + s->or_o)) * | 432 s->lr, s->rr, NULL, NULL, s->cr); |
253 M1_76DB + common); | 433 common += |
254 right = | 434 conv(dblen, hlen, s->cr, s->cr_ir, k + s->cr_o) * |
255 ( conv(dblen, hlen, s->rf, s->af_ir, k + s->af_o) + | 435 M1_76DB; |
256 conv(dblen, hlen, s->lf, s->of_ir, k + s->of_o) + | 436 left = |
257 (conv(dblen, hlen, s->rr, s->ar_ir, k + s->ar_o) + | 437 ( conv(dblen, hlen, s->lf, s->af_ir, k + s->af_o) + |
258 conv(dblen, hlen, s->lr, s->or_ir, k + s->or_o)) * | 438 conv(dblen, hlen, s->rf, s->of_ir, k + s->of_o) + |
259 M1_76DB + common); | 439 (conv(dblen, hlen, s->lr, s->ar_ir, k + s->ar_o) + |
260 } | 440 conv(dblen, hlen, s->rr, s->or_ir, k + s->or_o)) * |
261 else { | 441 M1_76DB + common); |
262 left = | 442 right = |
263 ( conv(dblen, hlen, s->lf, s->af_ir, k + s->af_o) + | 443 ( conv(dblen, hlen, s->rf, s->af_ir, k + s->af_o) + |
264 conv(dblen, hlen, s->rf, s->of_ir, k + s->of_o) + | 444 conv(dblen, hlen, s->lf, s->of_ir, k + s->of_o) + |
265 conv(dblen, hlen, s->lr, s->ar_ir, k + s->ar_o) + | 445 (conv(dblen, hlen, s->rr, s->ar_ir, k + s->ar_o) + |
266 conv(dblen, hlen, s->rr, s->or_ir, k + s->or_o) + | 446 conv(dblen, hlen, s->lr, s->or_ir, k + s->or_o)) * |
267 common); | 447 M1_76DB + common); |
268 right = | 448 } else { |
269 ( conv(dblen, hlen, s->rf, s->af_ir, k + s->af_o) + | 449 left = |
270 conv(dblen, hlen, s->lf, s->of_ir, k + s->of_o) + | 450 ( conv(dblen, hlen, s->lf, s->af_ir, k + s->af_o) + |
271 conv(dblen, hlen, s->rr, s->ar_ir, k + s->ar_o) + | 451 conv(dblen, hlen, s->rf, s->of_ir, k + s->of_o) + |
272 conv(dblen, hlen, s->lr, s->or_ir, k + s->or_o) + | 452 conv(dblen, hlen, s->lr, s->ar_ir, k + s->ar_o) + |
273 common); | 453 conv(dblen, hlen, s->rr, s->or_ir, k + s->or_o) + |
454 common); | |
455 right = | |
456 ( conv(dblen, hlen, s->rf, s->af_ir, k + s->af_o) + | |
457 conv(dblen, hlen, s->lf, s->of_ir, k + s->of_o) + | |
458 conv(dblen, hlen, s->rr, s->ar_ir, k + s->ar_o) + | |
459 conv(dblen, hlen, s->lr, s->or_ir, k + s->or_o) + | |
460 common); | |
461 } | |
462 break; | |
463 case HRTF_MIX_STEREO: | |
464 left = | |
465 ( conv(dblen, hlen, s->lf, s->af_ir, k + s->af_o) + | |
466 conv(dblen, hlen, s->rf, s->of_ir, k + s->of_o)); | |
467 right = | |
468 ( conv(dblen, hlen, s->rf, s->af_ir, k + s->af_o) + | |
469 conv(dblen, hlen, s->lf, s->of_ir, k + s->of_o)); | |
470 break; | |
471 default: | |
472 /* make gcc happy */ | |
473 left = 0.0; | |
474 right = 0.0; | |
475 break; | |
274 } | 476 } |
275 | 477 |
276 /* Bass compensation for the lower frequency cut of the HRTF. A | 478 /* Bass compensation for the lower frequency cut of the HRTF. A |
277 cross talk of the left and right channel is introduced to | 479 cross talk of the left and right channel is introduced to |
278 match the directional characteristics of higher frequencies. | 480 match the directional characteristics of higher frequencies. |
279 The bass will not have any real 3D perception, but that is | 481 The bass will not have any real 3D perception, but that is |
280 OK. */ | 482 OK (note at 180 Hz, the wavelength is about 2 m, and any |
483 spatial perception is impossible). */ | |
281 left_b = conv(dblen, blen, s->ba_l, s->ba_ir, k); | 484 left_b = conv(dblen, blen, s->ba_l, s->ba_ir, k); |
282 right_b = conv(dblen, blen, s->ba_r, s->ba_ir, k); | 485 right_b = conv(dblen, blen, s->ba_r, s->ba_ir, k); |
283 left += (1 - BASSCROSS) * left_b + BASSCROSS * right_b; | 486 left += (1 - BASSCROSS) * left_b + BASSCROSS * right_b; |
284 right += (1 - BASSCROSS) * right_b + BASSCROSS * left_b; | 487 right += (1 - BASSCROSS) * right_b + BASSCROSS * left_b; |
285 /* Also mix the LFE channel (if available) */ | 488 /* Also mix the LFE channel (if available) */ |
290 | 493 |
291 /* Amplitude renormalization. */ | 494 /* Amplitude renormalization. */ |
292 left *= AMPLNORM; | 495 left *= AMPLNORM; |
293 right *= AMPLNORM; | 496 right *= AMPLNORM; |
294 | 497 |
295 /* "Cheating": linear stereo expansion to amplify the 3D | 498 switch (s->decode_mode) { |
296 perception. Note: Too much will destroy the acoustic space | 499 case HRTF_MIX_51: |
297 and may even result in headaches. */ | 500 case HRTF_MIX_STEREO: |
298 diff = STEXPAND2 * (left - right); | 501 /* "Cheating": linear stereo expansion to amplify the 3D |
299 out[0] = (int16_t)(left + diff); | 502 perception. Note: Too much will destroy the acoustic space |
300 out[1] = (int16_t)(right - diff); | 503 and may even result in headaches. */ |
504 diff = STEXPAND2 * (left - right); | |
505 out[0] = (int16_t)(left + diff); | |
506 out[1] = (int16_t)(right - diff); | |
507 break; | |
508 case HRTF_MIX_MATRIX2CH: | |
509 /* Do attempt any stereo expansion with matrix encoded | |
510 sources. The L, R channels are already stereo expanded | |
511 by the steering, any further stereo expansion will sound | |
512 very unnatural. */ | |
513 out[0] = (int16_t)left; | |
514 out[1] = (int16_t)right; | |
515 break; | |
516 } | |
301 | 517 |
302 /* The remaining channels are not needed any more */ | 518 /* The remaining channels are not needed any more */ |
303 out[2] = out[3] = out[4] = 0; | 519 out[2] = out[3] = out[4] = 0; |
304 if(af->data->nch >= 6) | 520 if(af->data->nch >= 6) |
305 out[5] = 0; | 521 out[5] = 0; |
328 if ((s->rr = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | 544 if ((s->rr = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; |
329 if ((s->cf = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | 545 if ((s->cf = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; |
330 if ((s->cr = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | 546 if ((s->cr = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; |
331 if ((s->ba_l = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | 547 if ((s->ba_l = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; |
332 if ((s->ba_r = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | 548 if ((s->ba_r = malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; |
549 if ((s->fwrbuf_l = | |
550 malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | |
551 if ((s->fwrbuf_r = | |
552 malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | |
553 if ((s->fwrbuf_lr = | |
554 malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | |
555 if ((s->fwrbuf_rr = | |
556 malloc(s->dlbuflen * sizeof(float))) == NULL) return -1; | |
333 return 0; | 557 return 0; |
334 } | 558 } |
335 | 559 |
336 /* Allocate memory and set function pointers */ | 560 /* Allocate memory and set function pointers */ |
337 static int open(af_instance_t* af) | 561 static int open(af_instance_t* af) |
355 s->dlbuflen = DELAYBUFLEN; | 579 s->dlbuflen = DELAYBUFLEN; |
356 s->hrflen = HRTFFILTLEN; | 580 s->hrflen = HRTFFILTLEN; |
357 s->basslen = BASSFILTLEN; | 581 s->basslen = BASSFILTLEN; |
358 | 582 |
359 s->cyc_pos = s->dlbuflen - 1; | 583 s->cyc_pos = s->dlbuflen - 1; |
360 s->matrix_mode = 1; | 584 /* With a full (two axis) steering matrix decoder, s->matrix_mode |
585 should not be enabled lightly (it will also steer the Ls, Rs | |
586 channels). */ | |
587 s->matrix_mode = 0; | |
588 s->decode_mode = HRTF_MIX_51; | |
589 | |
590 s->print_flag = 1; | |
361 | 591 |
362 if (allocate(s) != 0) { | 592 if (allocate(s) != 0) { |
363 af_msg(AF_MSG_ERROR, "[hrtf] Memory allocation error.\n"); | 593 af_msg(AF_MSG_ERROR, "[hrtf] Memory allocation error.\n"); |
364 return AF_ERROR; | 594 return AF_ERROR; |
365 } | 595 } |