合唱音效解释

1. 1. 算法原理

[cpp] view plaincopyprint?

1. 合唱即多人一起唱歌，以下是算法的原理图：

[cpp] view plaincopyprint?

1. /*
2. *
3. *        * gain-in                                           ___
4. * ibuff -----+--------------------------------------------->|   |
5. *            |      _________                               |   |
6. *            |     |         |                   * level 1  |   |
7. *            +---->| delay 1 |----------------------------->|   |
8. *            |     |_________|                              |   |
9. *            |        /|\                                   |   |
10. *            :         |                                    |   |
11. *            : +-----------------+   +--------------+       | + |
12. *            : | Delay control 1 |<--| mod. speed 1 |       |   |
13. *            : +-----------------+   +--------------+       |   |
14. *            |      _________                               |   |
15. *            |     |         |                   * level n  |   |
16. *            +---->| delay n |----------------------------->|   |
17. *                  |_________|                              |   |
18. *                     /|\                                   |___|
19. *                      |                                      |
20. *              +-----------------+   +--------------+         | * gain-out
21. *              | Delay control n |<--| mod. speed n |         |
22. *              +-----------------+   +--------------+         +----->obuff
23. *
24. *
25. */

2. 代码实现

[cpp] view plaincopyprint?

1. void dsound_chorus_processmix(dsound_chorus_t* chorus, dsound_real_t *in,
2. dsound_real_t *left_out, dsound_real_t *right_out)
3. {
4. int sample_index;
5. int i;
6. dsound_real_t d_in, d_out;
7. for (sample_index = 0; sample_index < FLUID_BUFSIZE; sample_index++) {
8. d_in = in[sample_index];
9. d_out = 0.0f;
10. # if 0
11. /* Debug: Listen to the chorus signal only */
12. left_out[sample_index]=0;
13. right_out[sample_index]=0;
14. #endif
15. /* Write the current sample into the circular buffer */
16. chorus->chorusbuf[chorus->counter] = d_in;
17. for (i = 0; i < chorus->number_blocks; i++) {
18. int ii;
19. /* Calculate the delay in subsamples for the delay line of chorus block nr. */
20. /* The value in the lookup table is so, that this expression
21. * will always be positive.  It will always include a number of
22. * full periods of MAX_SAMPLES*INTERPOLATION_SUBSAMPLES to
23. * remain positive at all times. */
24. int pos_subsamples = (INTERPOLATION_SUBSAMPLES * chorus->counter
25. - chorus->lookup_tab[chorus->phase[i]]);
26. int pos_samples = pos_subsamples/INTERPOLATION_SUBSAMPLES;
27. /* modulo divide by INTERPOLATION_SUBSAMPLES */
28. pos_subsamples &= INTERPOLATION_SUBSAMPLES_ANDMASK;
29. for (ii = 0; ii < INTERPOLATION_SAMPLES; ii++){
30. /* Add the delayed signal to the chorus sum d_out Note: The
31. * delay in the delay line moves backwards for increasing
32. * delay!*/
33. /* The & in chorusbuf[...] is equivalent to a division modulo
34. MAX_SAMPLES, only faster. */
35. d_out += chorus->chorusbuf[pos_samples & MAX_SAMPLES_ANDMASK]
36. * chorus->sinc_table[ii][pos_subsamples];
37. pos_samples--;
38. };
39. /* Cycle the phase of the modulating LFO */
40. chorus->phase[i]++;
41. chorus->phase[i] %= (chorus->modulation_period_samples);
42. } /* foreach chorus block */
43. d_out *= chorus->level;
44. /* Add the chorus sum d_out to output */
45. left_out[sample_index] += d_out;
46. right_out[sample_index] += d_out;
47. /* Move forward in circular buffer */
48. chorus->counter++;
49. chorus->counter %= MAX_SAMPLES;
50. } /* foreach sample */
51. }

合唱音效解释